1
2
int n = 4;
int & r = n; // r引用了 n, r的类型是 int &

1
2
3
4
5
6
7
int n = 4;
int & r = n;
r = 4;
cout << r; //输出 4
cout << n; //输出 4
n = 5;
cout << r; //输出5

1
2
3
4
5
6
7
8
9
10
double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; 		// r2也引用 a
r2 = 10;
cout << a << endl; 		// 输出 10 对引用赋值会修改原变量的值
r1 = b; 			    // r1并没有引用b
cout << a << endl;      // 输出 5

int n = 4;
int & r = n * 5;        // 错误，不可以引用表达式

1
2
3
4
5
6
7
8
void swap(int & a,int & b)
{
	int tmp; tmp=a; a=b; b=tmp;
}

int x=1,y=2;
swap(x,y);
cout<<x<<" "<<y<<endl;  // 2, 1

1
2
3
4
5
6
7
8
int n = 4;
int & SetValue() {  return n; }

SetValue() = 40;  
//SetValue()返回n的引用，并赋值40 相当于以下两句 
//int & t = SetValue();
//t = 40;
cout<<n<<endl;  // 输出40

1
2
int n;
const int & r = n;  //r的类型是 const int &

1
2
3
4
5
int m = 100;
const int & w = m;
//w = 200; 		// 编译错
m = 300; 		// 没问题
cout << w << " " << m;  // 输出300 300

1
2
3
4
5
6
7
8
9
10
11
12
int n = 8;
const int & r1 = n;
//int & r2 = r1;     // 错误 不能用const初始化非const

const int q = 10;
const int & ww = q;  // 正确 使用常引用去引用常量
//int & e = q;       // 错误 常量不能去初始化非const的引用

int n = 8;
int & r1 = n;
const int r2 = r1;    // 正确 r2是常量，不管n、r1怎么变，r2都不变，且不能对r2赋值
const int & r3 = r1;  // 正确 r3是常引用，随着n、r1改变，但是不能对r3赋值

1
2
3
4
5
int n, m; 
const int * p = & n; 
* p = 5; 	//编译出错 
n = 4; 		//ok 
p = &m; 	//ok, 常量指针的指向可以变化

1
2
3
4
5
const int * p1; 
int * p2; 
p1 = p2; 			//ok 
p2 = p1; 			//error 
p2 = (int *) p1;    //ok, 强制类型转换

1
2
3
4
5
void MyPrintf( const char * p ) 
{ 
    strcpy( p, "this");  //编译出错 
    printf("%s", p);     //ok 
}

1
2
3
4
5
int a = 8;
int* const p = &a;
*p = 9; // 正确
int b = 7;
p = &b; // 错误

1
2
3
4
5
6
7
8
9
10
A& test(A& a) {
    return a;
}
// 不加const则可以这样：
test(a) = b;

const A& test(A& a) {
    return a;
}
// 加了const就不可以了

1
2
3
4
int* p;
p = new int;
*p = 5;
delete p;

1
2
3
4
5
6
int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
//pn[100] = 30; //编译没问题。运行时导致数组越界
delete [] pn;

1
2
3
4
5
inline int Min(int a,int b)//内联函数 
{
	if(a<b) return a;
	return b; 
}

1
2
3
4
5
6
7
8
9
10
11
int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }

Max(3.4,2.5); 	//调用 (1)
Max(2,4); 		//调用 (2)
Max(1,2,3); 	//调用 (3)
Max(3,2.4); 	//error,二义性

int f(int & a){}
int f(const int & a){}

1
2
3
4
void func( int x1, int x2 = 2, int x3 = 3) { }
func(10 ) ; 		//等效于 func(10,2,3)
func(10,8) ; 		//等效于 func(10,8,3)
func(10, , 8) ; 	//不行，只能最右边的连续若干个参数缺省

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class CRectangle
{
	public:
	int w, h;
	void Init( int w_,int h_ ) {
		w = w_; h = h_;
	}
}; 

CRectangle r;     //r是一个对象
r.Init(5,4);

CRectangle r1;
CRectangle * p1 = & r1;
p1->w = 5;
p1->Init(5,4);   //Init作用在p1指向的对象上
	
CRectangle & rr = r1;
rr.w = 5;
rr.Init(5,4);    //rr的值变了，r1也变了 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Complex{
	private:
		double real,imag;
	public:
		void Set(double r,double i=0);  // 只有函数声明，没有函数体
    	//void Set(double r);  			// 导致二义性
};

void Complex::Set(double r,double i)    // 这里不能再写i=0这个缺省参数了，否则编译错。
{
	real = r;
	imag = i;
}

Complex c3(); //这个适用于编译器的默认构造，也适用于自己写的无参构造
Complex c4;   //这个适用于编译器的默认构造，也适用于自己写的无参构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Complex{
	private:
		double real,imag;
	public:
		Complex();  //此时只有函数声明，需要在类外部补充函数定义 完整写法是：Complex(){};
		Complex(double r,double i=0);
};

Complex::Complex(double r,double i)
{
	this->real = r;
	this->imag = i;
}

Complex::Complex()   //定义无参构造函数！也需要写函数体，或者直接在声明处写{}
{
}

Complex c1(2);
Complex c2(2,4);
Complex * pc3 = new Complex(2,4);
delete pc3;
Complex c3();   //这个适用于编译器的默认构造，也适用于自己写的无参构造
Complex c4;     //这个适用于编译器的默认构造，也适用于自己写的无参构造

1
2
3
4
5
6
7
8
9
10
11
12
13
class Test {
	public:
	Test(int n) { } //(1)
	Test(int n, int m) { } //(2)
	Test() { } //(3)
};

Test a1[3] = { 1, Test(1,2) };
// 三个元素分别用(1),(2),(3)初始化
Test a2[3] = { Test(2,3), Test(1,2) , 1};
// 三个元素分别用(2),(2),(1)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) };
//两个元素分别用(1),(2) 初始化

1
2
3
4
5
6
7
8
9
10
11
class Complex{
	private:
		double real,imag;
	public:
    	Complex(double r,double i): real(r), imag(i) {}
    	// 等价于：
//	    Complex(double r,double i) {
//	        real = r;
//	        imag = i;
//	    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Test1
{
	public:
		int i;
		Test1(int a):i(a) {}
};

class Test2
{
	public:
		Test1 test1;
    	//使用初始化列表完成
		Test2(int x): test1(x) {} 
//		Test2(Test1 & t1) {  //error 因为Test1没有无参构造函数
//			test1 = t1;      //这样的赋值，首先需要默认初始化test1再赋值，导致报错
//		}
};

1
2
3
4
5
6
7
class Test3
{
	private:
	    const int a;                //const成员声明
	public:
	    Test3() :a(10) {}           //初始化
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Test4
{
	private:
	    int &a;                        //声明
	public:
	    Test4(int a_) :a(a_) {}        //初始化
};

class Test5
{
	public:
		Test1& test1;
		Test5(Test1& t1):test1(t1){}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
class Base {
public:
    int n;
    Base(int i):n(i) {}
    ~Base() {}
};

class Derived:public Base
{
public:
    Derived(int i):Base(i) {}  // 使用初始化列表初始化父类
    ~Derived() {}
};

1
2
3
4
5
6
7
class Complex { 
    private : 
        double real,imag; 
}; 

Complex c1; 		//调用缺省无参构造函数 
Complex c2(c1);		//调用缺省的复制构造函数，将c2初始化成和c1一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Complex{
	private:
		double real,imag;
	public:
		Complex(double r,double i=0);
		Complex(const Complex &c) { //复制构造函数，传进来的是引用 
			real = c.real;
			imag = c.imag;
			cout<<"copy"<<endl;
		}
};

Complex c1(2,3);    //正常调用构造函数
Complex c2(c1);		//调用复制构造函数
Complex c3=c1; 		//调用复制构造函数，初始化语句，非赋值语句 
c3=c1;				//变量之间的赋值不会调用复制构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A
{
	public:
	int v;
    A() { };
	A(int n) { v = n; }; 
	A(const A & a) {//复制构造函数 
		v = a.v;
		cout << "A Copy constructor called" <<endl;
	} 
};

void Func(A a1) { } 
void Func2(A & a1) { } 
void Func3(const A & a1) { }  //函数内部不能对a1赋值，也就保证了实参不会被修改。

A a2;
Func(a2);	//调用复制构造函数
Func2(a2);  //不会调用复制构造函数
Func3(a2);  //不会调用复制构造函数，且函数不会导致a2的值被改变

1
2
3
4
5
6
A Func4(){
	A b(4);
	return b;
}

cout<<Func4().v<<endl;	//调用复制构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A
{
	public:
	int v;
    A() { };
	A(int n) { v = n; };   //类型转换构造函数
};

A a1(4);          //调用类型转换构造函数
A a2 = 4;		  //调用类型转换构造函数，4被自动转换成一个临时的A的对象（初始化）
A a3; 			  //调用默认构造函数
a3 = 9;     	  //调用类型转换构造函数，9被自动转换成一个临时的A的对象（赋值）
A a4,a5; 		  //调用默认构造函数
a4 = a5;          //变量之间的赋值不会调用复制构造函数，也没有调用类型转换构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class String{
	private :
	char * p;
	public:
	String () {
		p = new char[10];
	}
	~ String () ;		//析构函数 
};

String ::~ String()
{
	delete [] p;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Ctest {
	public:
	~Ctest() { cout<< "destructor called" << endl; }
};

int main () {
    Ctest array[2];
    cout << "End Main" << endl;
    return 0;
}

输出：
End Main
destructor called
destructor called

1
2
3
4
5
6
Ctest * pTest;
pTest = new Ctest;    // 构造函数调用1次
delete pTest;         // 析构函数调用1次
	
pTest = new Ctest[3]; // 构造函数调用3次
delete [] pTest;      // 析构函数调用3次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class CMyclass {
	public:
    CMyclass() { cout << "constructed" << endl; }
    CMyclass(const CMyclass & x) { cout << "copy constructed" << endl; }
	~CMyclass() { cout << "destructor" << endl; }
};

CMyclass obj;   //main结束析构 

CMyclass fun(CMyclass sobj) { 	// 参数对象消亡也会导致析构函数被调用
	return sobj;                // 函数调用返回时，生成临时对象返回
}

int main()
{
	obj = fun(obj);		//函数调用的返回值（临时对象）被用过后，会被析构
	//这个赋值语句本身是给已经存在的对象obj赋值，不会调用任何构造函数
    return 0;
} 

// 输出：
constructed       //构造obj
copy constructed  //fun函数传参，导致调用复制构造函数
copy constructed  //fun函数返回对象，导致调用复制构造函数
destructor		  //析构fun函数的参数这个临时对象
destructor        //析构fun函数的返回值这个临时对象
destructor		  //析构obj

// 如果fun函数参数加引用，即fun(CMyclass & sobj)，则不会因为传参调用复制构造函数，也就不会产生临时对象，也就不会析构这个临时对象，导致缺少一个copy constructed和一个destructor。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class A { 
    public: int x; 
    A(int x_):x(x_) { 
        cout << x << " constructor called" << endl; 
    } 
    A(const A & a ) { //本例中dev需要此const其他编译器不要 
        x = 2 + a.x; 
        cout << "copy called" << endl; 
    } 
    ~A() { 
        cout << x << " destructor called" << endl; 
    } 
};

A f( ){ 
    A b(10); 
    return b; 
}

int main( ){ 
    A a(1); 
    a = f(); 
    return 0; 
}

//Visual Studio输出结果： 
1 constructor called      // 构造a 
10 constructor called     // 构造b
10 destructor called      // 析构b 因为b是局部变量
copy called               // 复制构造 因为f()函数返回值是对象，会产生一个临时对象，值=12
12 destructor called      // 析构f()函数的返回值这个临时对象
12 destructor called	  // 析构a 由于a=f()，此时a=12
    
//Dev C++输出结果：
1 constructor called      // 构造a 
10 constructor called     // 构造b
10 destructor called      // 析构b 因为b是局部变量
10 destructor called      // 析构a
//说明dev出于优化目的并未生成返回值这个临时对象

1
2
3
4
5
6
7
8
9
10
11
12
13
class CRectangle
{
	private:
		int w, h;
		static int nTotalArea;
		static int nTotalNumber;
	public:
		CRectangle(int w_,int h_);
		~CRectangle();
		static void PrintTotal();
};

int CRectangle::nTotalNumber=0;  // 静态成员的显式的初始化，需要写上类型 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Complex {
	public:
    double real, imag;
	void Print() {  cout << real << "," << imag ;  } 
    Complex(double r,double i):real(r),imag(i) { }
	Complex AddOne()  {
    	this->real ++;     //等价于 real ++; 
        this->Print();     //等价于 Print 
        return * this;
	}
}

class A {
    int i;
    public:
    void Hello() { cout << i << "hello" << endl; }
    //void Hello(A * this ) { cout << this->i << "hello" << endl; } 相当于这个
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class CTyre {
	public:
		CTyre() { cout << "CTyre contructor" << endl; }
		~CTyre() { cout << "CTyre destructor" << endl; }
};

class CEngine {
	public:
		CEngine() { cout << "CEngine contructor" << endl; }
		~CEngine() { cout << "CEngine destructor" << endl; }
};

class CCar {
	private:
		CEngine engine;
		CTyre tyre;
	public:
		CCar() { cout << "CCar contructor" << endl; }
		~CCar() { cout << "CCar destructor" << endl; }
};

CCar car;

/* 输出：
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class CCar ; //提前声明 CCar 类，以便后面的CDriver类使用

class CDriver
{
	public:
		void ModifyCar( CCar * pCar);
};

class CCar
{
	private:
		int price;
		friend int MostExpensiveCar( CCar cars[], int total); // 声明友元函数 
		friend void CDriver::ModifyCar(CCar * pCar); // 声明友元函数 
};

void CDriver::ModifyCar(CCar * pCar)
{
	pCar->price+=100;   // 直接访问price 
}

int MostExpensiveCar( CCar cars[], int total)
{
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A
{
	private:
		int price;
		friend class B;        // 声明B为A的友元类 B的成员函数可以访问A的私有成员 
};

class B
{
	public:
		A a;
		void f() {
			a.price += 1000;   // 因B是A的友元类，故此处可以访问其私有成员
		}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Sample {
	private :
		const int a;
		int value;
		mutable int mv;
	public:
		void func() { };
		Sample():a(10) { value = 10; }  // 使用初始化列表初始化a

		void SetValue() const {  // 常量成员函数 声明和定义都要const 
			//value = 0; // wrong
			//func();    //wrong
            mv = 8;
		}
		void PrintValue() const;  
    	void PrintValue();        // 重载
};

void Sample::PrintValue() const { // 此处不使用const 会导致编译出错
	cout << value + mv << endl;
}

void Sample::PrintValue() {
	cout << 2 * value + mv << endl;
}

void Print(const Sample & o) {
	o.PrintValue(); // 若PrintValue()非const则编译错 因为o是const的
}

const Sample Obj;   // 常量对象
Obj.SetValue(); 	// 常量对象上可以使用常量成员函数
Obj.PrintValue();	// 重载，自动使用常量成员函数

Sample Obj2;
Obj2.SetValue();    // 非常量对象上也可以使用常量成员函数
Obj2.PrintValue();	// 重载，自动使用非常量成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Complex {
public:
    double real, imag;
    Complex(double r = 0.0, double i = 0.0): real(r), imag(i) {}
    const Complex operator- (const Complex& c);
};

//重载为成员函数时  参数个数为运算符目数减一  -是双目 2-1=1 
const Complex Complex::operator-(const Complex& c) {
    return Complex(real - c.real, imag - c.imag);
}

//重载为普通函数时 参数个数为运算符目数 
const Complex operator+( const Complex & a, const Complex & b) {
    return Complex( a.real+b.real,a.imag+b.imag);
}

Complex a(4,4),b(1,1),c;
c = a + b; 	// 等价于c=operator+(a,b);
c = a - b; 	// 等价于c=a.operator-(b)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class String {
private:
    char * str;
public:
    String() : str(new char[1]) {
        str[0] = 'a';
    }
    const char* c_str() {
        return str;
    }
    String & operator= (const String& s) {
        if (this == &s) {
            return *this;
        }
        delete [] str;
        str = new char[strlen(s.str) + 1];
        strcpy(str, s.str);
        return *this;
    }
    String & operator= (const char * s) {
        delete [] str;
        str = new char[strlen(s)+1];
        strcpy( str, s);
        return * this;
    };
    String (const String & s) {  //拷贝构造函数 需要的参数是String
        if (this != &s) {
            str = new char[strlen(s.str) + 1];
            strcpy(str, s.str);
        }
    }
    ~String() {
        delete [] str;
    }
};

String s;
s = "Good Luck" ;    // 赋值语句不会调用复制构造函数，等价于s.operator=("Good Luck");
String s2(s);        // 这样的初始化语句会调用复制构造函数，这个是对的
String s2 = s;       // 这样的初始化语句会调用复制构造函数，这个是对的
//String s2("hello!");    // 这样的初始化语句会调用复制构造函数，这个是错的，参数错误
//String s2 = "hello!";   // 这样的初始化语句会调用复制构造函数，这个是错的，参数错误
s2 = s;              // 赋值语句不会调用复制构造函数，等价于s2.operator=(s);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Complex {
private:
    double real, imag;
public:
    Complex(double r, double i): real(r), imag(i) {}
    // Complex c; 可以 c+5 相当于c.operator+(5);
    const Complex operator+ (double r);
    // Complex c; 可以 5+c 相当于operator+(5,c);
    friend const Complex operator+( double r, const Complex & b);
};

const Complex operator+( double r, const Complex & b) {
    return Complex(b.real, b.imag+r);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
class CArray {
private:
    int size;
    int * ptr;
public:
    CArray(int len=0) : size(len) {
        if( len == 0)
            ptr = NULL;
        else
            ptr = new int[len];
    }
    CArray(const CArray& c) {  // 复制构造函数
        if (c.ptr == NULL) {
            ptr = NULL;
            size = 0;
            return;
        }
        ptr = new int[c.size];
        memcpy(ptr, c.ptr, sizeof(int)*c.size);
        size = c.size;
    }
    ~CArray() {
        if( ptr ) delete [] ptr;
    }
    void push_back(int v) {
        if(ptr) {  // 原本不为空 追加一个
            int * tmpPtr = new int[size+1];      // 重新分配空间
            memcpy(tmpPtr,ptr,sizeof(int)*size); // 拷贝原数组内容
            delete [] ptr;
            ptr = tmpPtr;
        }
        else {    // 数组本来是空的
            ptr = new int[1];
        }
        ptr[size++] = v; // 加入新的数组元素
    }
    CArray& operator= (const CArray& a) {  // 重载赋值运算符= 返回值是& 可以支持连等
        if (ptr == a.ptr) {
            return * this;
        }
        if (a.ptr == NULL) {
            if(ptr) delete [] ptr;
            ptr = NULL;
            size = 0;
            return * this;
        }
        if (size < a.size) { // 原来的空间不够大 需要申请
            if (ptr) delete [] ptr;
            ptr = new int[a.size];
        }
        memcpy(ptr, a.ptr, sizeof(int)*a.size);
        size = a.size;
        return * this;
    }
    int length() { return size;}
    int& operator[] (int i) { // 重载[] 返回值是& 可以支持a[i]=10;
        return ptr[i];
    }
};

CArray a;
a.push_back(1);
a.push_back(2);
CArray a2;
a2 = a;           //重载了=
a[0] = 100;       //重载了[]
CArray a3(a);     //实现了复制构造函数

1
2
3
4
5
6
7
8
9
10
ostream & ostream::operator<<(int n)
{
    // 输出n的代码
    return * this;
}
ostream & ostream::operator<<(const char * s )
{
    // 输出s的代码
    return * this;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Complex {
private:
    double real, imag;
public:
    Complex(double r, double i): real(r), imag(i) {}
    friend ostream& operator<< (ostream & os, const Complex & c); 
    friend istream& operator>> (istream & is, Complex & c); 
};

// 输出函数一般不修改c，所以加const
ostream& operator<< (ostream & os, const Complex & c) {
    os << c.real << "+" << c.imag << "i"; // 以"a+bi"
    return os;
}

// 把输入转成Complex类型，通过引用的作用返回回去
istream& operator>> (istream & is, Complex & c) {
    string s;
    is >> s; // 将"a+bi" 作为字符串读入，中间不能有空格
    int pos = s.find("+",0);
    string sTmp = s.substr(0,pos); // 分离出代表实部的字符串
    c.real = atof(sTmp.c_str()); //atof 库函数能将const char* 指针成 指向的内容转换成 float
    sTmp = s.substr(pos+1, s.length()-pos-2); // 分离出代表虚部的字符串
    c.imag = atof(sTmp.c_str());
    return is;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Complex {
private:
    double real, imag;
public:
    Complex(double r, double i): real(r), imag(i) {}
    void describe() const {
        cout << real << "+" << imag << "i" << endl; // 以"a+bi"
    }
//    explicit operator double() {  // 加explicit则需要显示转换 (double)c
//        return real;
//    }
    operator double() {  // 默认调用强制类型转换 重载double
        return real;
    }
//    operator int() {  //  默认调用强制类型转换 重载int
//        return (int)real;
//    }
};

int main() {
    Complex c(10.2,4.2);
    cout << c << endl;           //10.2
    cout << (double)c << endl;   //10.2
    double n = 2 + c;            
    cout << n << endl;           //12.2
    cout << 2+c << endl;         //12.2
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Cdmo {
private:
    int n;
public:
    Cdmo (int n_=0) : n(n_) {}
    // 重载前置运算符 ++a --a
    Cdmo& operator++() {
        n++;
        return *this;    //++a a本身变了
    }
    // 重载后置运算符 a++ a--
    Cdmo operator++(int) {
        Cdmo tmp(*this); //用temp保留*this
        n++;
        return tmp;
    }
    // 重载强制类型转换运算符int，用于输出
    operator int() {
        return n;
    }
    // 另一种方式 重载成全局函数
    friend Cdmo& operator--(Cdmo & c);
    friend Cdmo operator--(Cdmo & c, int);
};

Cdmo& operator--(Cdmo & c) {
    c.n--;
    return c;
}

Cdmo operator--(Cdmo & c, int) {
    Cdmo tmp(c);
    c.n--;
    return tmp;
}

Cdmo d(5);
cout << (d++);  // 输出5  因为重载了强制类型转换运算符，所以可以直接输出！
cout << d;      // 输出6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class CMyAverage {
	public:
	double operator () ( int a1, int a2, int a3 ) {
		//重载 () 运算符
		return (double)(a1+a2+a3) / 3;
	}
};

class MyLess {
	public:
		bool operator()( const int & c1, const int & c2 )
		{
			return (c1 % 10) < (c2 % 10);
		}
};

// 函数对象
CMyAverage average; 
cout << average(3,2,3) << endl; //函数对象，用起来看上去像函数调用 
cout << average.operator()(3,2,3) << endl; //和上一句是等价的  operator()是一个成员函数 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Bug {
private :
    int nLegs; int nColor;
public:
    int nType;
    Bug ( int legs, int color) : nLegs(legs), nColor(color) { }
    void PrintBug (){ cout << "Bug" << endl; }
};

class FlyBug: public Bug {  // public继承  可以多继承 
private:
    int nWings;
public:
    FlyBug(int legs, int color, int wings) :
            Bug(legs, color), nWings(wings) { }  // 初始化列表
    void PrintBug () {   // 覆盖
        Bug::PrintBug(); // 调用父类方法
        cout << "FlyBug" << endl;
    }
};

int main() {
    Bug bug(1,2);
    FlyBug fbug(1,2,3);
    fbug.PrintBug(); 
    //public继承 可以进行以下方法
    Bug bug2 = fbug;
    Bug& rbug = fbug;
    Bug* pbug = &fbug;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Father {
	private: int nPrivate;
    public:  int nPublic;
    protected: int nProtected;
}

class Son :public Father {
    void AccessFather () {
        nPublic = 1;     // ok;
        nPrivate = 1;    // wrong 
        nProtected = 1;  // OK，访问从基类继承的protected成员
        Son f;
        //f.nProtected = 1; //wrong ，f不是当前对象
    }
}

int main(){
    Father f; Son s;
    f.nPublic = 1;       //ok
    f.nProtected = 1;    //error
    f.nPrivate = 1;      //error
    s.nPublic = 1;       //ok
    s.nProtected = 1;    //error
    s.nPrivate = 1;      //error
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class Base {
public:
    int n;
    Base(int i):n(i) {  // 这里可以不用初始化列表
        cout << "Base " << n << " constructed" << endl;
    }
    ~Base() {
        cout << "Base " << n << " destructed" << endl;
    }
};

class Derived:public Base
{
public:
    Derived(int i):Base(i) {
        cout << "Derived constructed" << endl;
    }
    Derived():Base(10) {
        cout << "Derived constructed" << endl;
    }
    ~Derived() {
        cout << "Derived destructed" << endl;
    }
};

class MoreDerived:public Derived {
public:
    MoreDerived(int i) { // 不带初始化列表 因为基类有无参构造 
        cout << "More Derived constructed" << endl;
    }
    MoreDerived() {      // 不带初始化列表 因为基类有无参构造 
        cout << "More Derived constructed" << endl;
    }
    ~MoreDerived() {
        cout << "More Derived destructed" << endl;
    }
};

int main()
{
    MoreDerived Obj(20);
    return 0;
}

// 输出顺序为：
Base 10 constructed
Derived constructed
More Derived constructed
More Derived destructed
Derived destructed
Base 10 destructed

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class Base {
public:
    virtual void a() {
        cout << "Base-a" << endl;
    }
    void b() {
        cout << "Base-b" << endl;
    }
    void c() {
        a();
        b();
    }
};

class Derived:public Base {
public :
    virtual void a() {  // 子类的virtual可加可不加
        cout << "Drived-a" << endl;
    }
    void b() {   // 虽然跟基类同名同参数表，但是基类的b()不是虚函数，所以这个b()也不是
        cout << "Drived-b" << endl;
    }
};

int main() {
    Base b;  //父类直接调用，调用的全是父类的
    b.a();
    b.b();
    b.c();
    cout << "--------------" << endl;
    Derived o;
    o.a();  //virtual的 实现多态 调用自己的
    o.b();  //子类对象直接调用 没有virtual 但是调用的是自己的
    o.c();  //c()继承自父类 c()中调用a()方法virtual的是多态的；调用b()不是virtual是调用父类的
    cout << "--------------" << endl;
    //直接父类=子类的赋值 不能实现多态 调用的全是父类的
    Base b2 = o;
    b2.a();
    b2.b();
    b2.c();
    cout << "--------------" << endl;
    //指针和引用可以虚函数的实现多态
    Base * p = & o;
    p->a(); //a()是virtual的 多态
    p->b(); //b()不是virtual的 无法实现多态
    p->c(); //c()调用a()是多态的 调用b()是父类的
    cout << "--------------" << endl;
    Base & r = o;
    r.a();  //a()是virtual的 多态
    r.b();  //b()不是virtual的 无法实现多态
    r.c();  //c()调用a()是多态的 调用b()是父类的
    cout << "--------------" << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class son {
public:
    son() {cout<<"hi from son"<<endl;}
    virtual ~son() {cout<<"bye from son"<<endl;} //加virtual才能先析构子类再析构父类
};

class grandson : public son {
public:
    grandson() {cout<<"hi from grandson"<<endl;}
    ~grandson(){cout<<"bye from grandson"<<endl;}
};

int main(){
    son *pson;
    pson = new grandson(); //先构造父类 后构造子类 这个是正常的
    delete pson;  //父类析构函数加virtual才能先析构子类再析构父类，否则只析构父类

    grandson gs;  //普通的子类对象，先构造父类后构造子类，先析构子类再析构父类，不存在问题。
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class A { // 抽象类
private:
    int a;
public:
    A() {
        //Print();  // 构造函数和析构函数中不能调用纯虚函数
        fun();      // 构造函数和析构函数中可以调用普通函数
    }
    virtual void Print() = 0;      // 纯虚函数 
    virtual void Set(int n) = 0;   // 纯虚函数 
    void fun() { cout << "fun" << endl; }
    void fun2() { Print(); }  // 普通成员函数中可以调用纯虚函数
};

class B : public A {  // B继承自抽象类A，实现了A中全部的纯虚函数变成非抽象类
    virtual void Print() {
        cout << "bbb" << endl;
    }
    virtual void Set(int n) { }
};

int main(){
    //A a; 抽象类不可以有对象
    A* pa;
    //A* pa = new A;  抽象类不可以有对象
    B b;        // 构造父类的时候 输出fun
    b.fun();    // 继承自A 输出fun
    b.fun2();   // 继承自A 调用Print()是多态，输出bbb
    A& r = b;   // 多态 虽然A是抽象类
    r.fun2();   // 调用Print()是多态，输出bbb
    pa = &b;    // 多态 虽然A是抽象类
    pa->fun2(); // 调用Print()是多态，输出bbb
    return 0;
}

1
2
freopen("in.txt", "r", stdin);     // 将标准输入cin被改为从in.txt中读取数据
freopen("test.txt", "w", stdout);  // 将标准输出cout重定向到test.txt文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
ostream & tab(ostream &output) { // 自定义流操纵算子
    return output << '\t';
}

int main() {
    int n = 141;
//1)  分别以十六进制、十进制、八进制先后输出 n
    cout << "1) " << hex << n << " " << dec << n << " " << oct << n << endl;
    double x = 1234567.89,y = 12.34567;
//2)  保留5 位有效数字
    cout << "2) " << setprecision(5) << x << " " << y << " " << endl;
//3)  保留小数点后面5 位
    cout << "3) " << fixed << setprecision(5) << x << " " << y << endl ;
//4)  科学计数法输出，且保留小数点后面5 位
    cout << "4) " << scientific << setprecision(5) <<x << " " << y << endl ;
//5)  非负数要显示正号，输出宽度为12 字符，宽度不足则用'*' 填补
    cout << "5) " << showpos << fixed << setw(12) << setfill('*') << 12.1 << endl;
//6)  非负数不显示正号，输出宽度为12 字符，宽度不足则右边用填充字符填充
    cout << "6) " << noshowpos << setw(12) << left << 12.1 << endl;
//7)  输出宽度为12 字符，宽度不足则左边用填充字符填充
    cout << "7) " << setw(12) << right << 12.1 << endl;
//8)  宽度不足时，负号和数值分列左右，中间用填充字符填充
    cout << "8) " << setw(12) << internal << -12.1 << endl;
    cout << "9) " << 12.1 << endl;
    cout << "10) " << "aa" << tab << "bb" << endl;
    return 0;
}

1) 8d 141 215
2) 1.2346e+006 12.346
3) 1234567.89000 12.34567
4) 1.23457e+006 1.23457e+001
5) ***+12.10000
6) 12.10000****
7) ****12.10000
8) -***12.10000
9) 12.10000
10) aa  bb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <fstream>  //头文件
// 打开文件
ifstream srcFile("in.txt",ios::in);
ofstream destFile("out.txt",ios::out);

// 也可以先创建ofstream对象，再用open函数打开
ofstream fout;
fout.open("test.out",ios::out|ios::binary);

// 判断打开是否成功：
if(!fout) {...}

// 流操作
srcFile >> x;
destFile << x;

// 关闭文件
destFile.close();
srcFile.close();

1
2
3
4
5
6
7
8
9
10
11
12
13
long location = fout.tellp();  // 取得写指针的位置
location = 10;
fout.seekp(location);          // 将写指针移动到第10个字节处，location可以为负值
fout.seekp(location,ios::beg); // 从头数location 
fout.seekp(location,ios::cur); // 从当前位置数location 
fout.seekp(location,ios::end); // 从尾部数location

long location = fin.tellg();   // 取得读指针的位置
location = 10L;
fin.seekg(location); 		   // 将读指针移动到第10个字节处，location可以为负值
fin.seekg(location,ios::beg);  // 从头数location 
fin.seekg(location,ios::cur);  // 从当前位置数location 
fin.seekg(location,ios::end);  // 从尾部数location

1
2
3
4
5
6
7
8
9
10
ofstream fout("some.dat", ios::out | ios::binary);
int x = 120;
fout.write( (const char *)(&x), sizeof(int) );  //&x 是取x的内存地址
fout.close();

ifstream fin("some.dat", ios::in | ios::binary);
int y;
fin.read((char*) & y, sizeof(int));
fin.close();
cout << y <<endl;

1
2
3
4
5
6
7
template <class T>
void Swap(T & a, T & b)  // 模板函数
{
    T tmp = a;
    a = b;
    b = tmp;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 形参表一样 但是参数类型表不一样 也是重载
template<class T>
void print(T arg1, T arg2) {
    cout<< arg1 << " a "<< arg2<<endl;
}

template<class T,class T2>    // 定义了T2 但是没用
void print(T arg1, T arg2) {  // 全是T
    cout<< arg1 << " b "<< arg2<<endl;
}

print(1,1);
print(1.1,1.1);
// print(1,1.1); 匹配模板函数时，不进行类型自动转换 没有int,double对应的模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct node{
    int a,b,c;
};

template <> void Swap(node & a, node & b)  // 模板的显式具体化
{
    int t = a.a;
    a.a = b.b;
    b.b = t;
    t = a.b;
    a.b = b.a;
    b.a = t;
}

template void Swap<char>(char & a, char & b);  // 模板的显式实例化 不能写函数体

int x=2;y=2;
Swap<int>(x,y); // 强制调用模板函数
Swap<>(x,y);    // 强制调用模板函数

1
2
3
4
5
6
7
8
class A
{
    int v;
public:
    A(int n):v(n) { }
    template<class T>
	friend void print(T arg1, T arg2);  // 函数模板做类的友元 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
template <class T1, class T2>
class Pair {
public:
    T1 key;
    T2 value;
    Pair(T1 k, T2 v): key(k), value(v) { }
    bool operator< (const Pair<T1,T2> &p) const;  // 成员函数的声明
    template <class T3>  // 成员函数模板
           void func(T3 t) {
                cout << "hahaha " << t << endl;
           }
};

// 成员函数的实现
template <class T1, class T2>
bool Pair<T1, T2>::operator< (const Pair<T1, T2> & p) const {
    return key < p.key;
}

// 实例化出一个类 Pair<string,int>
Pair<string,int> student("Tom",19);
// 调用成员函数模板，成员函数模板被实例化
student.func("Liu");

Pair<string,int> *p;
Pair<string,double> a("LLL", 20.99);
//p = & a; //wrong

// 非类型参数
template <class T, int size> 
class CArray {
    T array[size];
public:
    void Print() {
        for( int i = 0;i < size; ++i)
            cout << array[i] << endl;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template <class T>
class A
{
private:
    static int count; //静态成员变量 
public:
    A() { count ++; }
    ~A() { count -- ; };
    A( A & ) { count ++ ; }
    static void PrintCount() { cout << count << endl; }  //静态成员函数 
};

template<> int A<int>::count = 0;  // 静态成员变量需要显式的初始化 需要写清楚变量类型 
template<> int A<double>::count = 0;

A<int> ia;
A<int> ib;
A<double> da;
ia.PrintCount();  // 输出2 A<int>是一个模板类 ia,ib是同一个类型 count是属于类的
ib.PrintCount();  // 输出2
da.PrintCount();  // 输出1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class T1,class T2>
class A {
    T1 v1; T2 v2;
};

template <class T1,class T2>
class B : public A<T2,T1> {  // 类模板从类模板派生
    T1 v3; T2 v4;
};

template <class T>
class C : public B<T,T> {    // 类模板从类模板派生
    T v5;
};

1
2
3
4
template <class T>
class D : public A<int,double> {  // 类模板从模板类派生
    T v;
};

1
2
3
4
5
6
7
8
class E {
    int v1;
};

template <class T>
class F : public E { // 类模板从普通类派生 所有从F实例化得到的类,都以E为基类
    T v;
};

1
2
3
class G : public A<int, double> {  // 普通类从模板类派生
    double v;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void Func() { }

class A { };

class B
{
public:
    void Func() { }
};

template <class T>  // 函数、类、类的成员函数作为类模板的友元
class Tmp
{
    friend void Func();
    friend class A;
    friend void B::Func();
}; // 任何从Tmp实例化来的类 ，都有以上三个友元

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <class T1,class T2>
class Pair   // 类模板
{
private:
    T1 key;
    T2 value;
public:
    Pair(T1 k,T2 v):key(k),value(v) { };
    // 函数模板作为类模板的友元
    template <class T3,class T4>
    friend ostream & operator<< ( ostream & o, const Pair<T3,T4> & p); 
};

template <class T3,class T4>
ostream & operator<< ( ostream & o, const Pair<T3,T4> & p) {
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
template <class T>
class BB {
    T v;
public:
    BB(T n) : v(n) { }
    //类模板作为类模板的友元
    template <class T2>
            friend class AA;
	//任何从AA模版实例化出来的类，都是任何BB实例化出来的类的友元
};

template <class T>
class AA {
public:
    void Func( )  {
        BB<int> o(10);
        cout << o.v << endl; // AA是BB的友元，AA的成员函数可以访问BB的私有成员。
    }
};

1
2
3
4
5
6
7
8
9
string s1("Hello");
string month = "March";
string s2(8,'x');     // 就是8个x，即xxxxxxxx
string s3(s2, 2, 4);  // s3=s2从2开始长度为4的子串
// 不能用数字或者字符类型进行初始化
// 但是可以用字符类型进行赋值
// string s3='n'; 错误
string s3;
s3 = 'n';

1
2
cin >> stringObject;
getline(cin ,s);

1
s1.length()

1
2
3
4
5
6
7
8
string s4,s5;
s4=s1;             // 赋值
s5.assign(s4);     // 赋值
s5.assign(s4,1,3); // 下标为1的字符开始复制3个字符
s1.assign(4,'x');  // 4个x
s1.assign("1234", 2);  // 字符串的前2个字符
s1.assign("1234");     // 整个字符串
s4[1] = 'a';       // 赋值

1
2
3
4
s4[1] = 'a';

for(int i=0;i<s1.length();i++)
	cout << s1.at(i) << endl; 

1
2
3
4
s1.begin();     // 指向字符串的第一个字符的正向迭代器
s1.end();       // 指向字符串的末尾(最后一个字符的下一个位置)的正向迭代器
s1.rebegin();   // 指向字符串的最后一个字符的逆向迭代器
s1.rend();      // 指向字符串的开头(第一个字符的前一个位置)的逆向迭代器

1
2
3
4
5
6
// 用 + 运算符连接字符串
s5+=s1;
// 用成员函数 append 连接字符串
s1.append(s2);
// 下标为3开始，s1.size()个字符，如果字符串内没有足够字符，则停止
s2.append(s1, 3, s1.size());  //s1.size()，s1字符数

1
2
3
4
5
6
7
8
// 用关系运算符比较string的大小，返回bool
// ==, >, >=, <, <=, !=
// 用成员函数compare比较string的大小，返回0,1,-1
s1.compare(s2);
s1.compare(1,2,s3); //s1的1开始的2个字符的子串; s3
s1.compare(1,2,s3,0,3); //s1的1开始的2个字符的子串; s3的0开始的3个字符的子串
s1.compare("222");
s1.compare(1,2,"222",2); //s1的1开始的2个字符的子串; "222"长度为2的子串

1
2
// 用成员函数substr
string s6 = s1.substr(3,5); // 下标3开始5个字符

1
2
3
// 用成员函数swap
string ss1("hello world"), ss2("really");
ss1.swap(ss2);

1
2
3
4
5
6
7
8
9
10
11
12
// find(str) 从前向后查找，找到返回位置下标，否则返回string::npos
// rfind(str) 从后向前查找，找到返回位置下标，否则返回string::npos
string s7("hello world"); 
s7.find("e");       //从下标0开始
s7.find("l",4);     //从下标4开始
s7.find("l",4, 5);  //从下标4开始，查找5个字符
s7.find(s1, 4);     //从下标4开始
s7.find('l',4);     //从下标4开始
// find_first_of(str) 从前向后查找，查找str中任何一个字符第一次出现的地方，如果找到返回找到字母的位置，如果找不到，返回string::npos
// find_last_of(str)  从后向前查找，查找str中任何一个字符第一次出现的地方，如果找到返回找到字母的位置，如果找不到，返回string::npos
// find_first_not_of() 从前向后查找，查找不在str中的字母第一次出现的地方，如果找到，返回找到字母的位置，如果找不到，返回string::npos
// find_last_not_of() 从后向前查找，查找不在str中的字母第一次出现的地方，如果找到，返回找到字母的位置，如果找不到，返回string::npos

1
2
3
// 用成员函数erase()
s7.erase(5);  // 去掉下标5及之后的字符
s7.erase();   // 删除所有字符

1
2
3
// 用成员函数replace()
s1.replace(2,3,"haha"); // 将s1中下标2开始的3个字符换成"haha"
s1.replace(2,3,"haha", 1,2); // 将s1中下标2开始的3个字符换成"haha"中下标1开始的2个字符

1
2
3
// 用成员函数insert()
s7.insert(5, s2);     // 将s2插入s7下标5的位置 
s7.insert(2,s2,5,3);  // 将s2中下标5开始的3个字符插入s7下标2的位置