C++笔记

1.构造函数C++放到private里

  构造函数用于初始列

 class complex
     {
          public:
              complex (double r = 0,double i = 0)
                   : re (r), im (i)
              {}
     }

  单例模型 ：只存在一个对象，外部通过A::getinstance();唯一接口访问

 class A{
    public:
        static A& getInstance ( return a;);
        setup(){...}
    private:
          A();
          A(const A& rhs);
          static A a;
          ...
     }

2.多个构造函数

  重载

3.尽量使用reference和inline

  内部定义的函数都可以定义为inline

4.友元函数打破了封装性

 可以直接取私有变量（不需要通过公共函数取）

5.return by reference or value

  创建的对象方式：类名称+（），并在（）里赋初值
  当函数是非成员函数时，全局函数，函数内部返回的是临时对象，即返回的必定是个local object，函数返回后就会销毁，所以不能返回引用。

  当函数是成员函数时，会有隐含的this对象，会将结果给到this对象，所以返回后没有销毁，可以返回引用。

6.随时注意要不要加const

7.运算符重载

 此时operator不能增加const变量，因为在return中，每次“<<”时，os都在变化。
 return的时local，当使用连续运算符时，必须返回引用。

8.构造函数和析构函数

 当离开{}时，P被delete掉，S1、S2调用析构函数
 如果没有delete p，就会出现内存泄漏，因为当作用域结束，p所指的heap object仍然存在，但指针p的生命却结束了，作用域之外再也看不到p

9.class with pointer 必须有 copy ctor 和 copy op=

可能会造成内存泄漏，或者指向同一区域，改变其一，另一个也会发生改变——浅拷贝
拷贝构造函数：

inline 
String :: String (const String& str)
{
      m_data = new char[ strlen (str.m_data) + 1 ];
      strcpy(m_data , str.m_data);
 }

拷贝复制函数 S1 = S2：将a清空，然后申请和b一样大的空间，最后将b内容复制到a

检测自我复制的作用就是防止a和b指向同一区域，杀掉a，那数据就都消失了

10.static local object 的生命周期

class Complex{};
...
{
      static Complex c2(1,2);
 }

c2便是所谓的static object ，其生命周期在作用域结束之后仍然存在，，知道整个程序结束。

11.new和delete ——内存分配和构造函数关联

delete ps；——————》String::~String(ps); //析构函数 operator delete(ps); //释放内存，内部调用free(ps)

12.static变量需要在类内声明类外定义（可初值）

13.static函数没有this point，可用来处理static数据

调用static函数的方式有二：
（1）通过object调用
Account a;
a.set_rate(7.0);
（2）通过class name调用
Account :: set_rate(7.0)

14.类模板

 template<typename T>
   class {...}

     {
          complex<double> c1 (2.5,1.5);  //需要指出<>类型
          complex<int> c2 (2,6);
     }

使用的时候需要指明类型<>

15.function template

{     
      stone r1(2,3),r2(3,3);
      r3 = min(r1,r2);     //不需要指出<>类型
 }

 编译器进行参数推导

 template <class T>          //class也可以替换为typename
    inline
    const T& min(const T& a, const T& b)
     {
          return b<a? b:a;
     }

推导结果为stone，于是调用stone的操作符<

 class stone
     {
          public:
              stone...
              bool operator< (const stone& rhs) const
                   {return _weight < rhs._weight; }
          private:
              int _w,_h,_weight;
     }

使用的时候不需要指明类型

16.Member Template 成员模板

p是pair<U1,U2>，规定将p的第一个U1（鲫鱼）放入T1（鱼类）中，使得first构造函数通过，

16.namespace

using namespace std;     //打开标准库，在使用不需要加std:: cin 全称
int main(){
      cin << ...;
 }
可以使用namespace分隔开，使得两个类或函数没有关联，每个namespace里可放相同的类名称。

17.复合

18.Inheritance with virtual

non-virtual函数：你不希望derived class重新定义（override）它。如父类的id，子类都要默认产生id。

virtual函数：你希望子类重新定义它，而且你对它已有默认定义。如父类的错误信息，有默认输出，允许子类重新定义更详细的输出。

pure-virtual函数：你希望derived class 一定要重新定义它，你对他没有默认定义。

class Rectangle ：public shape{...};
class Elipes ：public shape{...};

父类的Serialize()动作延缓到子类去执行

19.Inheritance + Composition 关系下的构造与析构

20.Delegation(委托)+Inheritance(继承)

 不知道未来子类的名称，通过子类创建静态的自己，然后自己调用私有构造函数挂到父类上去prototypes，然后执行父类的findAndClone，clone的动作是new自己，然后父类调用clone函数查看到子类副本。

21.conversion function ，转换函数

 （1）注意没有返回类型
 （2）函数名称比较特别，如 operator string
 （3）不改变，只转变类型，所以const

22.pointer-like classes，关于智能指针

 sp->等价于px，C++规定为px要有->

23.pointer-like classes ，关于迭代器

node指向节点结构
 operator*=(*node).data

24.function-like classes，所谓仿函数

 任何一个东西能够接受一个()操作符，那就成为函数或是像函数

25.specialization，模板特化

 cout <<hash<char>()('a'); hash()创建对象。

26.偏特化

 绑定一个模板参数

范围偏特化：任意范围特化成指针类型

27.模板模板参数

28.三大主题

改变容器内的元素，需要传引用。

29.reference