C plus plus day3

栈、堆、类模板、函数模板、static

Stack：是存在于某作用域的一块内存空间。列如当你调用函数，函数本身会形成一个stack用来放置它所接收的参数，以及返回地址。

             在函数本体内声明的任何变量，其所使用的内存都来自stack

Heap：是指由操作系统提供的一块全局内存空间，程序可动态分配从其中获得若干区块。

 

用new取得的在作用域外也可以使用，不用时需要释放内存空间

一般的函数只能在作用域内使用，离开作用域就死亡了。自动调用析构函数

{
    complex c1(1,2)
}

 static对象  其生命在作用域结束之后仍然存在 直到整个程序结束。

{
    static complex c1(1,2)
}

 

 全局对象  在任何{}外的 生命在整个程序结束后才消失

堆对象的生命期  不加delete会造成内存泄露

{
complex* p = new complex；得到p指针
...
delete p;
}

 

new ：先分配内存 再转型  调用构造函数

delete：先调用析构函数  在释放内存

inline
String::String(const char* cstr =0)
{
    if(cstr){// 分配足够空间  还有一个结束符号  字符串要有最后一个结束符
        m_data = new char[strlen(cstr)+1];//array new 需要搭配array delete  数组形式分配内存空间
        strcpy(m_data,cstr);
    }
    else{   //未指定初值   new分配一个字符内存  结束符号
        m_data = new char[1];
        *m_data = '\0';
    }
}

inline
String::String()
{
    delete[] m_data; //动态分配内存 使用完就要把内存释放 防止内存泄露
}

 

array new 一定要搭配 array delete

    String *p = new String[3];
    ...
    delete[] p;

 

创建三个数组对象  如果只是 delete p 就会只唤起一次 析构函数

 

class Account
{
public:
    static double m_rate;
    static void set_rate(const double& x){m_rate = x;}
};
double Account::m_rate =8.0;
//静态变量建议在class外 赋初值

                                                   调用static函数的方式有2：
                                                   1、通过对象直接调用
                                                   2、通过classname 调用
int main()
{
    Account::set_rate(5.0);
    Account a;
    a.set_rate(7.0)
}

 

类模板

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

};
{
    complex<double> c1(2.5,1.5);  调用时可以根据不同类型来调
    complex<int> c2(2,6);
}

 

函数模板

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;}
    ~stone();
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;   看stone里面有没有 ‘<’操作符
r3 = min(r1,r2);   引用推导   调用stone::operator<

 

c++中的算法都是template function.