C++笔记

class Clock {

public:

   Clock() =default; //指示编译器提供默认构造函数

   Clock(int newH, int newM, int newS);     //构造函数

private:

   int hour, minute, second;

};

#include <iostream>
using namespace std;
//类定义
class Clock {
public:
    Clock(int newH,int newM,int newS);//构造函数
    void setTime(int newH, int newM, int newS);
    void showTime();
private:
    int hour, minute, second;
};

//构造函数的实现：
Clock::Clock(int newH,int newM,int newS): hour(newH), minute(newM), second(newS){}
int main(){
  	Clock c(0, 0, 0);//自动调用构造函数
  	c.showTime();
	return 0;
}

委托构造函数
类中往往有多个构造函数，只是参数表和初始化列表不同，其初始化算法都是相同的，这时，为了避免代码重复，可以使用委托构造函数。

Clock类的两个构造函数：

Clock(int newH, int newM, int newS) : hour(newH),minute(newM),  second(newS)  {  //构造函数
}
Clock::Clock(): hour(0),minute(0),second(0) { }//默认构造函数

委托构造函数使用类的其他构造函数执行初始化过程

例如：

Clock(int newH, int newM, int newS):  hour(newH),minute(newM),  second(newS){
}
Clock(): Clock(0, 0, 0) { }

复制构造函数
复制构造函数是一种特殊的构造函数，其形参为本类的对象引用。作用是用一个已存在的对象去初始化同类型的新对象。

复制构造函数定义

class 类名 {
public :
类名（形参）；//构造函数
类名（const 类名 &对象名）；//复制构造函数
// …

}；

类名::类（ const 类名 &对象名）//复制构造函数的实现

{ 函数体 }
如果不希望对象被复制构造
C++98做法：将复制构造函数声明为private，并且不提供函数的实现。
C++11做法：用“=delete”指示编译器不生成默认复制构造函数。

例：

class Point {   //Point 类的定义
public:
    Point(int xx=0, int yy=0) { x = xx; y = yy; }    //构造函数，内联
    Point(const Point& p) =delete;  //指示编译器不生成默认复制构造函数
private:
    int x, y; //私有数据
};

复制构造函数被调用的三种情况：

定义一个对象时，以本类另一个对象作为初始值，发生复制构造；

如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造；

如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化一个临时无名对象，传递给主调函数，此时发生复制构造。

类组合程序举例

#include <iostream>
#include <cmath>
using namespace std;
class Point {	//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 << "Calling the copy constructor of Point" << endl;
}

//类的组合
class Line {//Line类的定义
public:	//外部接口
	Line(Point xp1, Point xp2);
	Line(Line &l);
	double getLen() { return len; }
private://私有数据成员
	Point p1, p2;//Point类的对象p1,p2
	double len;
};

//组合类的构造函数

Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) {
	cout << "Calling constructor of Line" << endl;
	double x = static_cast<double>(p1.getX() - p2.getX());
	double y = static_cast<double>(p1.getY() - p2.getY());
	len = sqrt(x * x + y * y);
}

Line::Line (Line &l): p1(l.p1), p2(l.p2) {//组合类的复制构造函数
	cout << "Calling the copy constructor of 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;
	return 0;
}

前向引用声明
类应该先声明，后使用
如果需要在某个类的声明之前，引用该类，则应进行前向引用声明。
前向引用声明只为程序引入一个标识符，但具体声明在其他地方。
例：

class B;  //前向引用声明
class A {
public:
  void f(B b);
};
class B {
public:
  void g(A a);
};

前向引用声明注意事项

使用前向引用声明虽然可以解决一些问题，但它并不是万能的。
在提供一个完整的类声明之前，不能声明该类的对象，也不能在内联成员函数中使用该类的对象。
当使用前向引用声明时，只能使用被声明的符号，而不能涉及类的任何细节。

例：

class Fred; //前向引用声明
class Barney {
   Fred x; //错误：类Fred的声明尚不完善
};
class Fred {
   Barney y;
};