第一周
1. C++编程简介
目的：正规大气的编程习惯，大家风范的正规写法
class两种经典分类：
class without pointer member （基于对象 - Object Base ）
class with pointer member（面向对象- Object Oriented）
Class之间的关系
--继承（inheritance）
--符合（composition）
--委托（delegation）
C++学习包括: C++语言+ C++标准库
2. 头文件与类声明
数据与函数：
C:数据是全局的，所有的函数都可以处理
C++：将数据与处理数据的函数包在一起
C++的结构几乎等同于class，只有微小差别
虚数类：
应用时以class为类型建立很多对象
数据有很多份，函数只有一份，用一个函数来处理很多的数据
字符串类：
只有一个指针，内容存在另外分配的内存中，每个对象大小只有一个指针
C++程序代码的基本形式：
.h(header files),.cpp
延伸文件名（extension file name），不一定是.h或.cpp,也可能是.hpp或者其他甚至没有延伸名
头问文件的写法(防卫式声明)：
complex.h
#ifndef __COMPLEX__
#define __COMPLEX__
....
#endif
Header 头文件的布局
#ifndef __COMPLEX__
#define __COMPLEX__
#include <cmath>
class ostream; ///前置声明 - forward declarations
/////////////////////////////////
class complex ///类生命 - class declarations
{
};
/////////////////////////////////
complex::function() ///类定义 - class definition
{
}
#endif
class声明
class complex // class head
{
public: // class body
complex (double r = 0, double i = 0): re (r), im (i) { }
complex& operator += (const complex&);
double real () const { return re; }
double imag () const { return im; }
private:
double re, im;
friend complex& __doapl (complex *, const complex&);
}
模板简介：
templtate<typename T>
class complex // class head
{
public: // class body
complex (double r = 0, double i = 0): re (r), im (i) { }
complex& operator += (const complex&);
double real () const { return re; }
double imag () const { return im; }
private:
T re, im; //T为模板，表示类型未定
friend complex& __doapl (complex *, const complex&);
}
{
complex<double> cl(2.5,1.5);
complex<int> cl(2,5);
}
3. 构造函数
有些函数在body中定义，另一些在body之外定义
{
complex c1(2,1);
complex c2;
}
inline函数，比较快
内联函数：
内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。内联函数从源代码层看，有函数的结构，而在编译后，却不具备函数的性质。
编译器没有能力将所有函数做诶inline处理，可以建议编译器做inline处理，但是否是inline由编译器处理
在本体内定义，自动处理为inline函数，不在本体内定义，显示定义inline
访问级别：
公开的：public，私有的：private，被保护的：protected
数据级别可交错，所有数据必须放在private里
构造函数：
class complex
{
public:
complex (double r = 0, double i = 0) ///默认实参 - default agument
: re (r), im (i) ///初值列 - initialization list
{ }
complex& operator += (const complex&);
double real () const { return re; }
double imag () const { return im; }
private:
double re, im;
friend complex& __doapl (complex *, const complex&);
};
构造函数名称和类名相同,没有返回值
赋值方式：有限利用初值列
一个数据赋值有两个阶段，先初始化，再赋值，利用初值列，在初始化时赋值。
不带指针的类，多半不需要写析构函数
函数重载（overloading）：
同名函数可以出现一个以上，编译器以函数名称和参数名分辨应该调用哪个函数
4. 参数传递与返回值
把构造函数放在private区域里
singleton
class A
{
public:
static A& getIntance();
setup(){};
private:
A();
A(const A & rhs)
};
A& A::getInstance() ///通过这个函数获取单体类
{
static A a;
return a;
}
常量成员函数：
函数对对象的数据不做改变时，函数加const
类和函数在设计时就需要确定是否改变数据
double real () const { return re; }
double imag () const { return im; }
不加时，出现常量对象时，不能调用该函数
{
const complex c1(1,2);
cont << c1.real();
cont << c2.imag();
}
参数传递
pass by value和pass by reference（to const）
按引用传值效率高，速度快，优先考虑，尽量传引用
引用和指针类似
引用时，不希望对方改变，加const
返回值传递：
return by value和return by reference（to const）
优先选择引用
friend（友元）
class complex
{
public:
complex (double r = 0, double i = 0): re (r), im (i) { }
complex& operator += (const complex&);
complex& operator -= (const complex&);
complex& operator *= (const complex&);
complex& operator /= (const complex&);
double real () const { return re; }
double imag () const { return im; }
private:
double re, im;
friend complex& __doapl (complex *, const complex&);
friend complex& __doami (complex *, const complex&);
friend complex& __doaml (complex *, const complex&);
};
inline complex&
__doapl (complex* ths, const complex& r)
{
ths->re += r.re; ///可以直接取数据
ths->im += r.im;
return *ths;
}
相同class的各个object互为friend（友元）
class complex
{
public:
complex (double r = 0, double i = 0): re (r), im (i) { }
int func(const complex & param)
{return param.re + param.im;}
private:
double re,im;
}
{
comolex c1(2,1);
complex c2;
c2.func(c1);
}
返回时方式的选择：
inline complex&
__doapl (complex* ths, const complex& r)
{
ths->re += r.re; ///第一个参数将被改动
ths->im += r.im; ///第二个参数不变
return *ths;
}
如果一个返回值是本来就在的，不是函数内分配的内存，就可以用引用
如果一个返回值是局部变量，不能返回引用
5. 操作符重载与临时对象
在C++里操作符就是一种函数，是可以重新定义的
操作符重载-1 成员函数 （this）
数据放在二元操作符左侧，编译器将符号作用于左操作数身上，编译为对应函数，右操作数为参数
complex::operaror += (const complex &r)
{
return __doapl(this,r);
}
所有成员函数带着一个隐藏的参数，this pointer，表示调用者的指针
complex::operaror += (this,const complex &r) ///错误，不用显示写this
{
return __doapl(this,r);
}
return by reference
传递者无需知道接受者是以reference形式接收，写法都一样
inline complex&
__doapl (complex* ths, const complex& r)
{
ths->re += r.re; ///第一个参数将被改动
ths->im += r.im; ///第二个参数不变
return *ths;
}
返回值为vaule，不用管接收者的接收方法
考量使用者连串使用： c3 += c2 += c1
全域函数
操作符函数-2 非成员函数(无this)，全局函数
c2= c1 + c2;
c2 = c1 + 5;
c2 = 7 + c1;
返回local opbject时，绝不可以return by reference
tapename() 定义一个临时对象，下一行结束生命
函数内的临时对象不能return by reference
<<被重载时，不能被写成成员函数，必须写成全局函数
加了const 函数内部不能更改传入的值
向ostream类型对象输入数据后，会改变其状态
为了连续使用 << ，重载函数的返回类型不能为void
总结
设计类时需要注意的几个语法点：
头文件，防卫式定义的头文件
类名（head）
数据（私有）
构造函数（初值列），默认值，参数传递方式等
重载运算符（成员函数与非成员函数）
函数是否改变数据值，不改变加const
内联函数
返回值方式，只要不是临时变量值，就用引用
非成员函数（全局函数设计）
