Question

c++组合类问题，急

c++新手菜鸟，遇到一个组合类问题,弄不明白，看不下去了，希望前辈们帮帮忙，感激不尽！！！越详细越好，一步一步来，不然我看不懂，整个程序是怎么运行的？？最好能还能有解释 （100分追加，拜托！！！）
#include<iostream>
#include<cmath>
using namespace std;
class Point
{
public :
Point(int xx=0,int yy=0){X=xx;Y=yy;}
Point(Point &p);
int GetX() {return X;}
int GetY() {return Y;}
private:
int X,Y;
};
Point::Point(Point &p) //拷贝函数的实现
{
X=p.X;
Y=p.Y;
cout<<"Point拷贝函数被调用"<<endl;
}
//类的组合
class Line
{
public:
Line(Point xp1,Point xp2);
Line(Line &);
double GetLen(){return len;}
private:
Point p1,p2;
double len;
};
//组合类的构造函数
Line::Line(Point xp1,Point xp2)
:p1(xp1),p2(xp2)
{
cout<<"Line构造函数被调用"<<endl;
double x=double(p1.GetX()-p2.GetX());
double y=double(p1.GetX()-p2.GetY());
len=sqrt(x*x+y*y);
}
//组合类的拷贝构造函数
Line::Line(Line &L):p1(L.p1),p2(L.p2)
{
cout<<"Line 拷贝构造函数被调用"<<endl;
len=L.len;
}
//主函数
int main()
{
Point myp1(1,1),myp2(4,5); //建立Point类的对象
Line line(myp1,myp2); //建立Line类的对象
Line line2(line); //利用拷贝构造函数建立一个新对象
cout<<"The length of the line is :";
cout<<line.GetLen()<<endl;
cout<<"The length of the line2 is :";
cout<<line2.GetLen()<<endl;
}

Answer 1

// 教科书总是喜欢把简单的东西神秘化、复杂化。
// 给你一个简单,等效,更优雅的代码段看看吧.
#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
Point(void);
Point(const Point& pt);
explicit Point(int x, int y);
~Point(void);
public:
int GetX(void) const {return m_nX;}
int GetY(void) const {return m_nY;}
protected:
int m_nX;
int m_nY;
};

// 拷贝构造函数的功效就是将参数中的对象所拥有的数据
// 拷贝到自己当前这个对象,也就是this对象的里面.
Point::Point( const Point& pt )//拷贝函数的实现
{
this->m_nX = pt.m_nX;
this->m_nY = pt.m_nY;
cout << "Point拷贝函数被调用" << endl;
}

Point::Point( int x, int y )
: m_nX(x), m_nY(y)
{
}

Point::Point( void )
: m_nX(0), m_nY(0)
{
}

Point::~Point( void )
{
}

// 这里上面的Point对象严格来说应该定义成结构,因为其中不牵扯接口、方法、计算, 而只是有数据,
// 定义成类只会让你更加一头雾水,反而不能理解类的真正意义.

// 下面的Line类才是真正具备了数据和计算功能.但是稍有经验者绝对不会把计算操作放在构造函数中,
// 想象一下如果这个计算操作需要一个小时,但是这个对象必须在程序初始化时被构造,那么按照原来的写法,
// 我就要恭喜你写了个启动时间超长的"大程序".在将来你还可能遇到会抛出异常的计算、操作...
// 这一切如果发生在构造或者析构时,那是非常令人头疼的.
// 记得,构造函数是用来构造、初始化的,不要像教科书一样把计算操作放在里面.他们写出再烂的程序也不会被炒鱿鱼.
class Line
{
// 保证这个无参的默认构造函数不会被任何人调用
private:
Line(void);
public:
explicit Line(int nXStart, int nYStart, int nXEnd, int nYEnd);
Line(const Line& line);
~Line(void);
public:
double CalculateLineLength();
protected:
int m_nXStart;
int m_nYStart;// 可以将m_nXStart,m_nYStart,看作原先的p1对象
int m_nXEnd;
int m_nYEnd;// 可以将m_nXEnd,m_nYEnd,看作原先的p2对象
bool m_bAlreadyCalc;// 避免重复计算
double m_nLineLength;
};

Line::Line( int nXStart, int nYStart, int nXEnd, int nYEnd )
: m_nXStart(nXStart), m_nYStart(nYStart)
, m_nXEnd(nXEnd), m_nYEnd(nYEnd)
, m_bAlreadyCalc(false)
, m_nLineLength(0.0F)
{

}

// 这里的Line&类型是Line对象的一个引用,并不分配内存或产生临时对象,
// 而原来代码段中的Line::Line(Point xp1,Point xp2),参数是Point类型,而不是Point&类型,
// 所以调用这种构造函数时,会产生临时对象,想象一下产生一个Point对象需要如果消耗2分钟的时间
// 那么这个调用就是至少4分钟...是不是很恐怖...
// 所以Line::Line(const Point& xp1, const Point& xp2)的声明会更好,因为加上了const表示不会更改原先
// Point对象的内容,只是读取和拷贝.等效于Line::Line(Point xp1,Point xp2),却具备更高的效率.
Line::Line( const Line& line )
{
// memcpy(this, &line, sizeof(Line));
// 可以自己试试上面这句是不是等同于下面5句.
m_nXStart = line.m_nXStart;
m_nYStart = line.m_nYStart;
m_nXEnd = line.m_nXEnd;
m_nYEnd = line.m_nYEnd;
m_bAlreadyCalc = line.m_bAlreadyCalc;
m_nLineLength = line.m_nLineLength;
}

Line::~Line( void )
{

}

double Line::CalculateLineLength()
{
if (!m_bAlreadyCalc)
{
// 这样便不需要每次调用该函数都重复做同样的计算.
m_bAlreadyCalc = true;
// C++标准的类型转换为static_cast,reinterpret_cast,dynamic_cast,const_cast这四种
// 可以去网上查查用法,比C语言传统的强制类型转换更加安全有效.
double fXDistance = static_cast<double>(m_nXStart - m_nXEnd);
double fYDistance = static_cast<double>(m_nYStart - m_nYEnd);
// sqrt为开平方函数.
m_nLineLength = sqrt(fXDistance * fXDistance + fYDistance * fYDistance);
}
return m_nLineLength;
}

//主函数
int main()
{
Line line(1, 1, 4, 5);// 建立Line类的对象
cout << "The length of the line is :" << line.CalculateLineLength() << endl;
// 利用拷贝构造函数建立一个新对象,由于上一个对象line的CalculateLineLength函数已经被调用过
// 所以其m_bAlreadyCalc的值被置为了true,拷贝构造函数会将这个值赋予line2对象的m_bAlreadyCalc
// 这样虽说分别调用了两个对象的CalculateLineLength函数,其实需计算一次即可解决问题.
Line line2(line);
cout << "The length of the line2 is :" << line2.CalculateLineLength() << endl;
}

Answer 2

#include<iostream>//c++的输入输出流头文件
#include<cmath>//数学头文件，包含了大部份的数学公式
using namespace std;//引用 命名空间 std 是标准命名空间
class Point
{
public :
Point(int xx=0,int yy=0){X=xx;Y=yy;} //构造函数，初始化X Y
Point(Point &p);//重载构造函数，把已有的Point拷贝到新的Point
int GetX() {return X;} //提取 X的值
int GetY() {return Y;} //提取Y 的值
private:
int X,Y;
};
Point::Point(Point &p) //拷贝函数的实现
{
X=p.X;
Y=p.Y;
cout<<"Point拷贝函数被调用"<<endl;
}
//类的组合
class Line
{
public:
Line(Point xp1,Point xp2); //构造函数，
Line(Line &); //重载构造函数
double GetLen(){return len;} //返回len的值
private:
Point p1,p2;
double len;
};
//组合类的构造函数
Line::Line(Point xp1,Point xp2)
:p1(xp1),p2(xp2)
{
cout<<"Line构造函数被调用"<<endl;
double x=double(p1.GetX()-p2.GetX());
double y=double(p1.GetX()-p2.GetY());
len=sqrt(x*x+y*y); //sqrt 开方函数
}
//组合类的拷贝构造函数
Line::Line(Line &L):p1(L.p1),p2(L.p2)
{
cout<<"Line 拷贝构造函数被调用"<<endl;
len=L.len;
}
//主函数
int main()
{
Point myp1(1,1),myp2(4,5); //建立Point类的对象
Line line(myp1,myp2); //建立Line类的对象
Line line2(line); //利用拷贝构造函数建立一个新对象
cout<<"The length of the line is :";
cout<<line.GetLen()<<endl;
cout<<"The length of the line2 is :";
cout<<line2.GetLen()<<endl;
}

Point myp1(1,1),myp2(4,5);
初始化 myp1，myp2
隐性调用了 myp1.myp1（1，1）
myp2.myp2（4，5）

Line line(myp1,myp2);

初始化 line myp1 myp2 作为构造函数的参数
隐性调用 line.Lne（myp1，myp2）

Line line2(line); 初始化line2

隐性调用 line2.Lne（line）
把line中的数据拷贝到 line2

cout<<"The length of the line is :";

cout<<line.GetLen()<<endl;

先运行 line.GetLen() 返回 line的Len值
然后输出 换行

cout<<"The length of the line2 is :";
cout<<line2.GetLen()<<endl;
同line

Answer 3

你虽然在类ca中有一个类cb的指针，
但是，这个指针没有被初始化啊！
你直接进行
a.callcb();
程序会执行
b->funa();
问题是：这个时候的指针
b，并没有指向任何
cb
对象，访问肯定会出错的！