C++：面向对象高级编程

• 大气的编程习惯
  （1）尽可能使用构造函数的初始化列表
  （2）函数传参时尽量传引用：在条件允许下尽量传const引用
  （3）函数返回值尽量返回引用
  （4）如果函数不需要修改对象状态则声明为常量成员函数：常对象只能调用常量成员函数
  （5）数据部分尽可能private
• C++的演化
  
• C++的组成
  
• C++类的两个经典分类
  （1）不带指针成员变量的类：class without pointer members
  （2）带指针成员变量的类：class with pointer members
• 基于对象(Object Based) vs 面向对象(Object Oriented)
  （1）基于对象：单一的class设计：类与类之间都是单一的，没有联系
  （2）面向对象：多重class的设计：类与类之间是存在各种关系的
• 类之间的关系
  （1）组合：has-a
  （2）继承：is-a vs is-like-a
  （3）委托
• C vs C++：关于数据与函数
  
• C/C++头文件防重复包含

#ifndef __COMPLEX_H__
#define __COMPLEX_H__

...

#endif // __COMPLEX_H__

• 类模板（class template）vs 函数模板（function template）

template <class T>
class complex {
	// 函数模板作为类模板的友元
	template <class E> // 这句话不能省略: 是不是E无所谓
	friend complex<E>& __doapl(complex<T> *, complex<E> &);

	template <class E>
	friend ostream& operator<<(ostream &, const complex<E> &);
public:
	complex(T r = 0, T i = 0) : re(r), im(i) {}
public:
	complex& operator+=(const complex &r) { // r: right
		re += r.re;
		im += r.im;
		return *this;
	}
public:
	T real() const {return re;}
	T imag() const {return im;}
private:
	T re, im; // 复数的实部(re)与虚部(im)
};

// do assignment plus
template <class T>
complex<T>& __doapl(complex<T> *l, complex<T> &r) {
	l->re += r.re;
	l->im += r.im;
	return *l;
}

template <class T>
ostream& operator<<(ostream &os, const complex<T> &c) {
	os << "(" << c.re << "," << c.im << ")";
	return os;
}

int main(int argc, char *argv[], char *envp[]) {
	complex<double> c1(1, 2), c2(2, 3);
	c1 = __doapl(&c1, c2);
	cout << c1 << endl;


	system("pause");
	return 0;
}

• 内联函数（inline function）
  （1）若函数的实现是在类体内完成的，那么函数就自动成员内联函数
• 访问控制：其实就是作用域：访问控制是封装的基础
• 构造函数：唯一的作用就是对象的初始化
  
  （1）构造函数可以有多个：函数重载
  （2）构造函数可以有默认参数
• 构造函数放在private区：一般用作单例设计模式

class Singleton {
public:
	static Singleton& getInstance() {
		static Singleton s;
		return s;
	}
private: // 构造函数放在private区
	Singleton() {}
};

• 常量成员函数：只能是实例成员函数：常量成员函数中的const的意思是说我保证不改变对象的状态

class complex {
public:
	// 常量成员函数只能是：实例成员函数
	void foo1() const{} // OK

	// 常量成员函数中不能修改：实例成员变量: 但类成员变量是可以修改的
	void foo4() const {
		count = 10; // OK
		v = 2;		// ERROR
	}

	// error C2270: 'foo3' : modifiers not allowed on nonmember functions
	// static void foo2() const {} //ERROR

private:
	static int count; 	// 类成员变量
	int v; 				// 实例成员变量
};

int complex::count = 0;

// error C2270: 'foo3' : modifiers not allowed on nonmember functions
// void foo3() const {} // ERROR

• 如果非要在常量成员函数中改变实例成员变量的值：那么将实例成员变量声明为mutable即可
  
• 参数传递：传值（pass by value） vs 传引用（pass by reference [to const]）：尽可能的传递引用：如果在被调函数内部不需要修改对象的状态，尽量传递const的引用

class complex {
	friend ostream& operator<<(ostream &, const complex &);
private:
	double re, im;
};

/*
* 第一个参数: os不能是const的：因为每次<<操作都会修改os对象的状态
* 第二个参数：c可以是const的，因为不需要修改c对象的状态
*/
ostream& operator<<(ostream &os, const complex &c) {
	os << "(" << c.re << "," << c.im << ")";
	return os;
}

• 函数返回值处理：return by value vs return by reference [to const]
  （1）什么情况下可以return by value：
  （2）什么情况下可以return by reference：只要返回的对象不是局部的非静态的对象都可以return by reference
• 友元：相同class的各个对象互为友元
• 运算符重载：实例成员函数 vs 全局函数