C++面向对象编程<七>：堆栈、类模板、函数模板及其他补充

stack堆、heap栈

stack：所谓栈就是存在于作用域的一块内存空间，如当你调用函数，函数本身就会形成一个stack用来放置它所接受的参数及local object，以及返回地址；
heap：指操作系统提供的一块global内存空间，程序可能动态分配空间，并取得，并且要自己释放。
如下

class Complex {...};
...
{
    Complex c1(1,2);               //c1在stack
    static Complex c2(1,2);        
    Complex* p = new Complex(3);   //在heap里
}

c1便是所谓的stack object,其声明在作用域就会结束（上面看来就是离开括号），又叫做auto object；而c2便是所谓的static object，其生命在作用域结束之后还在，直到整个程序结束。
如下为全局

class Complex {...};
...

Complex c3(1,2);       

int main()
{
    ...
}

c3便是global object，其生命在整个程序结束之后才结束。其作用域是整个程序。
看一个正确的写法

class Complex {...};
...

{
    Complex* p = new Complex;
    ...
    delete p;
}
//p是所谓的heap object，其生命在它被delete后便结束了

看一个错误的写法

class complex {};
...
{
complex *p = new complex;
}
/*
会出现内存泄露，当作用域结束后，p所指的heap object任然存在，但指针p的生命却结束，作用域之外再也看不到p，也就没有机会delete p了
*/

• new、delete
  使用如下

Complex* p = new Complex(1,2);
...
delete p;

其中new操作会被转换为下面的步骤

Complex* p;

void* mem = operator new (sizeof(Complex) );  //分配内存
p = static_cast<Complex*>(mem);               //类型转换 
p->Complex::Complex(1,2);                     //构造函数 

/*
operator new就是一个函数，主要功能分配空间，而构造函数会转换为
Complex::Complex(p,1,2);p就是this指针
*/

其中new的操作步骤示意图如下：

delete的操作会被转换为如下：

Complex::~Complex(p);              //析构函数 
operator delete(p);               //释放内存 

再看一个使用如下：

String* p = new String[3];
...
delete[] p;  //调用三次析构函数
//delete p; 调用一次析构函数

其中delete的操作步骤示意图如下：

其实new是调用C的malloc函数（分配的空间比申请的空间大），delete函数是调用C的free函数，记住一个new对应一个delete。

类模板、函数模板及其他补充

• static

关系图如下：

类complex成员函数只有一份（不可能创建了几个对象就有几个函数），但是要处理很多对象，那就得靠this pointer来处理不同的对象。
而static的部分就和对象脱离了，它存在于内存的一部分，只有一份。
什么时候会使用static对象呢？就是和对象无关的部分。
如银行会有很多客户对象，但利率却不会和对象有关（大体部分来说）
staic成员函数和一般成员函数的特征就是static成员函数没有this pointer，既然没有this pointer，那static 成员函数不能和一般的函数一样去访问处理non-static data members，那只能处理static members

下面看一个栗子，如下：

class Account
{
    public:
    static double m_rate;
    static void set_rate(const double& x) {m_data = x };
};

double Account::m_rate = 8.0;   //静态数据必须要这样定义，因为脱离对象，

int main()
{
    Account::set_rate(5.0);
    Account a;
    a.set_rate(7.0);
}

可以看出调用static函数的两种方式：
1. 通过object调用
2. 通过class name 调用

• 单例模式

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

A& A::getInstance()
{
    return a;
}

a本来就存在，和对象无关，然后不想其他人创建，那就把构造函数放在private里，那怎么取得a呢，就用个static A& getInstance()取得a，这是与外界的接口。但这不是最好的写法，因为不管你用不用，a都存在。所以更好的写法如下

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

A& A::getInstance()
{
    static A a;   //只有当有人掉用这个函数，a才会存在
    return a;
}

• cout
  为什么cout能接受不同类型的参数呢？如下图
  
  可以看出cout就是一种ostream，
  可以看出cout实际上是重载了<<运算符的函数，用于打印不同类型的数

• template
  分为两种：class template 和 function template
  class template见下程序

template<typename T>
class complex
{
    public:
        complex (T r = 0, T i = 0)
        : re (r), im(i)
        {}
        complex& operator += (const complex&);
        T real() const {return re; }
        T imag() const {return im; }
    private:
        T re, im;

        friend complex& _doapl (complex*, const complex&);
};

//调用如下
{
    complex<double> c1(2.5,1.5);
    complex<int> c2(2,6);
}

function template见下程序

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

    private:
        int _w, _h, _weight;
};

template<class T>
inline const T& min(const T& a, const T& b)
{
    return b < a ? b : a; 
}

//使用
stone r1(2,3), r2(3,3), r3;
r3 = min(r1,r2);  //则会调用min函数，函数里面会接着调用stone::operator<函数

• namespace
  以防写的东西与别人同名。使用方法有两种，见下两种：
  using directive：

using namespace std; //把namspace空间的东西全打开
cin >> i;
cout << "hello" << endl;

using declaration：

using std::cout;
std::cin >> i;
cout << "hello" << endl;