20:52 提问
C++类的组合的构造函数问题
为什么构建Line的时候要4次拷贝构造函数point，另外为什么拷贝构造line2的时候，又要调用2次point的拷贝构造函数。
Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2){}
这种写法是组合类的拷贝构造特有的么，这是什么意思，特别是后面的p1(xp1),p2(xp2)。
#include&iostream&
#include&cmath&
class Point
Point(int xx=0,int yy=0)
cout&&"Point构造函数被调用"&&
Point(Point &p);//拷贝函数
int GetX() { return X; }
int GetY() { return Y; }
Point::Point(Point &p)//拷贝构造函数的实现
cout&&"Point拷贝构造函数被调用！"&&
//类的组合
class Line
Line(Point xp1,Point xp2);//构造函数
Line(Line &);//拷贝函数
double GetLen() { }
Point p1,p2;
//组合类的构造函数
Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2)
cout&&"Line构造函数被调用"&&
double x=double(p1.GetX()-p2.GetX());
double y=double(p1.GetY()-p2.GetY());
len=sqrt(x*x+y*y);
//组合类的拷贝构造函数
Line::Line(Line &L):p1(L.p1),p2(L.p2)
cout&&"Line拷贝构造函数被调用"&&
int main()
Point myp1(1,1);
Point myp2(4,5);//建立Point类的对象
Line line(myp1,myp2);
Line line2(line);
cout&&"The length of the line is:";
cout&&line.GetLen()&&
cout&&"The length of the line2 is:";
cout&&line2.GetLen()&&
按赞数排序
# Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2){}//解释4次的原因：
# 首先这个方法是Line的构造函数,它有2个参数，类型为Point，(注意：不是引用(Point&),也不是指针(Point*))
# 其次，冒号后面的叫构造函数的初始化列表，用于初始化成员变量
# 知道这两点之后，那么再来说原因：
# c++这门语言不像java，如果参数不写成引用（Point&）或者指针（Point*），那么再传递参数的时候会建立一个对象的副本。
# 再来看看这个Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2){}，传入xp1时，会去创建一个Point的对象，调用1次Point的拷贝构造，
这是第1次，同理xp2，再进行p1(xp1)时，这又会调用1次Point的拷贝构造，同理p2(xp2)，因此共4次
一般来说这个方法最好这么写Line::Line(const Point& xp1,const &Point xp2):p1(xp1),p2(xp2){},这样就只会调2次了
----------------------biu~biu~biu~~~在下问答机器人小D，这是我依靠自己的聪明才智给出的答案，如果不正确，你来咬我啊！
冒号，初始话列表方式初始化变量。
Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2){}//解释4次的原因：
首先这个方法是Line的构造函数,它有2个参数，类型为Point，(注意：不是引用(Point&),也不是指针(Point*))
其次，冒号后面的叫构造函数的初始化列表，用于初始化成员变量,注意是初始化
知道这两点之后，那么再来说原因：
c++这门语言不像java，如果参数不写成引用（Point&）或者指针（Point*），那么在传递参数的时候会建立一个对象的副本。
再来看看这个Line::Line(Point xp1,Point xp2):p1(xp1),p2(xp2){}，传入xp1时，会去创建一个Point的对象，调用1次Point的拷贝构造，这是第1次，同理xp2，再进行p1(xp1)时，这叫初始化p1,不是定义之后再赋值！这又会调用1次Point的拷贝构造，同理p2(xp2)，因此共4次
一般来说这个方法最好这么写Line::Line(const Point& xp1,const Point& xp2):p1(xp1),p2(xp2){},这样就只会调2次了
准确详细的回答，更有利于被提问者采纳，从而获得C币。复制、灌水、广告等回答会被删除，是时候展现真正的技术了！
其他相关推荐C++构造函数问题_百度知道
C++构造函数问题
classA{}classB{private:vector&A*&a;//****}B类构造函数是否需要初始化a，怎么初始化？...
class A {}class B{private:
vector&A*&//****}B类构造函数是否需要初始化a，怎么初始化？
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
藤原子大雄
来自电脑网络类芝麻团
藤原子大雄
采纳数：3682
获赞数：1612
擅长：暂未定制
参与团队：
1.构造函数当然没有返回值，他只是描述了类初始化的行为。2.但是new是有返回值的啊！new返回的一定是类实例的指针啊，所以new tree返回的是tree*，所以构造函数跟返回该类的空间是没有关系的。下面举个例子给你看看：#include &iostream&#include &fstream&#include &algorithm&#include &string&#include &cstring&#include &vector&#include &queue&class tree {public:tree(int v):value(v){}int get_value() {}};int main(int argc, char *argv[]){//ifstream in_file(&zhidao.text&);queue&tree*&for (int i = 0;i& 10 ;++i ){tree * tmp = new tree(i);q.push(tmp);}//test codewhile(!q.empty()){cout&&q.front()-&get_value()&&& &;q.pop();}cout&&return 0;}
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。关于C++类构造函数调用问题
[问题点数：40分，结帖人hy]
本版专家分：86
结帖率 91.67%
CSDN今日推荐
本版专家分：39985
2014年11月 C/C++大版内专家分月排行榜第三
本版专家分：7068
2017年8月 C/C++大版内专家分月排行榜第三
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
本版专家分：86
本版专家分：86
本版专家分：86
本版专家分：0
本版专家分：86
本版专家分：86
本版专家分：86
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
匿名用户不能发表回复！
其他相关推荐
谈谈关于构造函数中调用虚函数的情况，仅讨论单继承，不考虑虚拟继承和多重继承。
测试平台：VS2013 + Win7X64
一个例子：
class Base
this-&Func();
virtual void Func()
{cout&&&consB1&&&i&&}
};//定义基类B1
{cout&&&consB2&&&j&&}
};//定义基类B2
java-----构造函数调用构造函数，使用this
class Person
Person(String name,int age)
//this.name=
this(name);
C++中，静态成员函数可以访问静态成员变量和静态成员函数，因为类的非静态成员函数会传入一个隐藏的this指针，这是大家都知道的。非静态的成员函数是属于类的，不属于某个对象，所以不含有this指针，所以只能调用静态成员函数和静态成员函数，但是今天在实现单例模式（一个类只能拥有一个对象时发现静态成员函数可以访问构造函数，难道构造函数是静态的吗？）class Signalleton{
转自: http://blog.sina.com.cn/s/blog_01agz7.html
一、单继承
核心：在构造子类之前一定要执行父类的一个构造函数。
1.构造函数（不包括复制构造函数）。
顺序：①直接父类；②自己
注意：若直接父类还有父类，那么“直接父类的父类”会在“直接父类” 之前 构造。
1 #include
4 struct C180
this-&foo();
virtual void foo() {
cout && this & vtadr: & void**)thi
其实就是使用this来实现的。看一下例子就会明白的了。
class Class1
public Class1()
public Class1(string s)
public Class1(int i, string j)
int main()
A* p = new A[2]; //调用两次构造函数
请按任意键继续. . .
一个变量只能调用一次构造函数，那就是在定义变量的时候调用，除非变量为局部变量，否则不会重复调用，一直到程序结束也就调用那么一次。也就是说只有在定义新的变量的时候才会调用构造函数。
【eg1】定义在主函数的情况
1. 重载构造函数
构造函数也具备了重载的特性。
class rectangle
rectangle(){cout
rectangle(int l,int w){length=l;width=w;cout
length * width
rectangle(int l,int w浅谈c++构造函数问题,初始化和赋值问题
&更新时间：日 09:19:46 & 投稿：jingxian
下面小编就为大家带来一篇浅谈c++构造函数问题,初始化和赋值问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
默认构造函数（就是没有参数的构造函数）
The Default Constructor
The default constructor is the constructor used to create an object when you don't provide explicit initialization values. That is, it's the constructor used for declarations like this:
Stock stock1;& // uses the default constructor
1、由编译器自动生成
2、由我们自己定义的
这里又有两种情况
上面说了啊，default constructor有两种（……your own default constructor. This is a constructor that takes no arguments）：
1）One is to provide default values for all the arguments to the existing constructor:
Stock(const char * co = "Error", int n = 0, double pr = 0.0);
2）The second is to use function overloading to define a second constructor, one that has no arguments:
有一点注意的时候两者不能同时使用：
You can have only one default constructor, so be sure that you don't do both. (With early versions of C++, you could use only the second method for creating a default constructor.)
This is a constructor that takes no arguments：这个指的是调用的时候不带参数。
编译器自动添加默认构造函数的条件：编译器实现的构造函数其实就是什么都不做
1.没有任何自己定义的构造函数（即便是复制构造函数也不行，如果自己定义复制构造函数，则必须自己定义构造函数）
2、数据成员中没有const和reference。--因为要初始化。
拷贝构造函数的参数必须是引用的原因：拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝， 而是避免拷贝构造函数无限制的递归下去。
如果是值的话，那在传值的时候还要再调一次拷贝构造函数
然后又要传值，又要再调一次....
然后你就内存不够，当了
关于赋值==函数和拷贝构造函数的区别：
#include&iostream&
A( const A& a)
cout&&"copy is build"&&
explicit A(int y)
A fun(A i)
{ A a1(i);
A a2=a1;//其实就调用拷贝构造函数
return a2;
int main()
&拷贝构造函数一共调用四次拷贝构造函数。。fun参数传值一次，a1（i）一次，a2（a1）一次，return的时候构造临时对象一次
如果函数返回对象，而不是指针，那么在执行return的时候，会使用被return的对象“复制构造”临时对象，然后，return语句执行完毕(遇到分号;了)函数内部创建的全部变量析构、出栈。而被“赋值构造”的临时对象则在调用该函数的语句执行完毕(遇到分号;或者右边的大括号})后，析构。
总结一句：
临时变量的生存范围是语句级——分号;结束或者右边的大括号}结束。语句结束之后，临时变量就被析构了~
以上就是小编为大家带来的浅谈c++构造函数问题,初始化和赋值问题全部内容了，希望大家多多支持脚本之家~
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具1添加评论分享收藏感谢收起class A
A & operator= (const A & a)
class B : public A
virtual void vf() = 0;
B & operator= (const B & b)
this-&A::operator=(b);
class C : public B
cout && "class C" &&
C & operator= (const C & c)
this-&B::operator=(c);
int main()
B *pb = new C;
B &b = C();
输出为：class Cclass C通过这段代码能知道一个事实：抽象类B无法实例化，但是却可以创建指针和引用来指向或者引用派生类C的对象。那么，对于抽象类B，拥有赋值函数是否有必要呢？我认为是有必要的。对于赋值函数，类C继承自抽象类B，那么在类C中需要调用到基类A的赋值函数该怎么办呢？类C没有直接继承自基类A，无法直接调用，所以自然只能通过抽象类B的赋值函数来调用，所以抽象类B也需要有赋值函数。说完必要性再来说说充分性（笑）充分性也即是说有赋值函数“可不可以有”。答案其实很简单，看上面程序就能看到，创建抽象类B的引用是合理的，所以只要在写赋值函数的时候将形参和返回值都写成引用就可以了。理解上的话，因为引用是可以引用派生类C的对象的，所以该赋值函数其实是完成派生类C的对象中”基类B所定义的部分的赋值“，所以也是十分合理的。总结一下，题主的第一个问题的答案也就出来了：赋值函数中的参数可以使用引用的方式，因为并没有实例化抽象类B的对象。至于拷贝构造函数，实测是可以有的，只是参数也需要为引用。赞同 添加评论分享收藏感谢收起写回答}