程序=数据结构+算法

一般来讲，把要解决的实际问题中的对象的共同特性->数据结构，把行为->函数(算法)这一过程叫做抽象。

把类的定义，包含数据结构和算法紧密联系起来这一过程叫做封装。

对象/实例 是 类的变量名，生成一个实例的过程称之为实例化。

对象的大小相当于sizeof(对象中所有变量的和)，每个对象有各自的存储空间

code如下:

class CRectangle
{
    public:
        int w,h;
        int Area();
        void Init(int _w,int _h);
};
int CRectangle::Area() //具体定义写在class内部的话，就不用有CRectangle::
{
    return w*h;
}
void CRectangle::Init(int _w,int _h) //具体定义写在class内部的话，就不用有CRectangle::
{
    w=_w;h=_h;
}


//访问方法
1.对象名.成员名
CRectangle r；
r.w=5;
2.指针
CRectangle r；
CRectangle* p=&r;
p->w=5;
3.引用名.成员名
CRectangle r；
CRectangle & ref_r=&r;
ref_r.w=5;

注意，对象名作为实参传递时，会拷贝一份(复制构造函数)。所以一般传递的是引用或者指针。

访问权限

通过public，private和protected关键字实现。注意:默认是private的。

protected除了自己，子类的指针或引用也可以访问。

可以通过friend关键字在类内声明友元函数，达到private的部分权限释放功能。友元函数，友元类。

B是A的友元类说明B的成员函数可以访问A的私有变量，友元的关系不能传递或者继承。

class A
{
    friend class B;    //B是A的友元类
    friend void B::func();//classB的func可以访问A的私有变量
    friend func_pub();
}

内联函数

整个函数出现在类定义内部，默认是内联函数。

重载

函数名相同，参数不同，可以重载。注意，有缺省值的函数容易出错使得重载有二义性。

封闭类

类成员变量中有其他类的对象的时候，该类称之为封闭类。封闭类一般都需要自己写初始化，因为封闭类中的成员对象的初始化一般无法由系统自动完成。

封闭类的构造函数的执行顺序是，先执行成员对象的构造函数，然后执行封闭类的构造函数。

析构函数的顺序是，先执行封闭类的析构函数再执行成员对象的析构函数。

封闭类的构造函数一般使用初始化列表构造，这是因为，初始化列表相比赋值，如果有形参是对象，直接调用复制构造函数。如果不使用，会先调用默认构造函数再进行操作符重载的赋值操作。所以在初始化列表有自定义类的时候，理论上速度上会快一些。

code:

INIT(string s, int i):name(s), id(i){};

初始化

class CTypeInit{  
public:  
    CTypeInit( int c):m_c(c),m_ra(c){  
    }  
private:  

    int m_a;                //通过初始化列表初始化，  
                            //或者构造函数初始化  
    /*引用*/  
    int &m_ra;              //只能通过初始化列表初始化  

    /*静态变量*/  
    static int m_b;         //不能通过初始化列表初始化，  
                            //不能在类内进行初始化，  
                            //不能在构造函数中初始化，  
                            //只能在类外初始化  

    /*常量*/  
    const  int m_c;         //只能通过初始化列表初始化，  
                            //不能在类内进行初始化，  
                            //不能在构造函数中初始化，  
                            //不能在类外初始化  

    /*静态整型常量*/  
    static const int m_d;   //（整型）能否在类中初始化，取决于编译器  
                            // 能在在类外初始化，不能带static  

    /*静态非整型常量*/  
    static const double m_e;//（double型）能否在类中初始化，取决于编译器  
                            // 能在在类外初始化，不能带static  
};  

//静态成员变量，必须在类外初始化,且要去掉static关键字  
int CTypeInit::m_b = 6;  
const int CTypeInit::m_d = 6;  
const double CTypeInit::m_e = 3.1415926;  

int main()  
{  
    CTypeInit obT(2);  
    return 0;  
}