C++关键字

int* pInt = new int(3);　　　　　　　　　　　　// 分配并构造一个int
double* pDoubleArray = new double[5];　　　 // 分配了一个double数组，其大小是5

delete pInt;　　　　　　　　　　　　　　　　　　 // 删除单元素
delete[] pDoubleArray;　　　　　　　　　　　　 // 删除数组

虽然new的本质是去调用malloc，但是new 和 malloc还有一点很大的不同。那就是new 出来内存后，new会帮你把对象给构造出来，而malloc只是分配内存。具体例子如下：

class MyObj {
public:
　　public MyObj(int value) : val(value) {}
　　int val;
};

MyObj* obj = new MyObj(4);
MyObj* obj1 = (MyObj*) malloc(sizeof(MyObj));

new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。

自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图分配自己没被授权的内存区域。关于C++的类型安全性可说的又有很多了 

1 class A{...}
2 A * ptr = new A;
3 A * ptr = (A *)malloc(sizeof(A)); //需要显式指定所需内存大小sizeof(A);

class A
{
public:
    A() :a(1), b(1.11){}
private:
    int a;
    double b;
};
int main()
{
    A * ptr = (A*)malloc(sizeof(A));
    return 0;
}

1 int main()
2 {
3     A * ptr = new A;
4 }

void * operator new (sieze_t size)
{
    if(void * mem = malloc(size)
        return mem;
    else
        throw bad_alloc();
}
void operator delete(void *mem) noexcept
{
    free(mem);
}

因为，如果定义了很多register变量，可能会超过CPU的寄存器个数，超过容量。所以只是可能。

数据从内存里拿出来先放到寄存器，然后CPU 再从寄存器里读取数据来处理，处理完后同样把数据通过寄存器存放到内存里，CPU 不直接和内存打交道。

速度！就是因为速度。寄存器其实就是一块一块小的存储空间，只不过其存取速度要比内存快得多。

进水楼台先得月嘛，它离CPU 很近，CPU 一伸手就拿到数据了，比在那么大的一块内存里去寻找某个地址上的数据是不是快多了？

 
	

		
		

			class GrandFather   
		

		

			{  
		

		

			public:   
		

		

			    GrandFather() {}  
		

		

			    virtual void fun()   
		

		

			    {  
		

		

			        cout << "GrandFather call function!" << endl;   
		

		

			    }  
		

		

			};  
		

		

			  
		

		

			class Father : public GrandFather   
		

		

			{  
		

		

			public:   
		

		

			     Father() {}  
		

		

			     void fun()   
		

		

			     {  
		

		

			         cout << "Father call function!" << endl;   
		

		

			     }  
		

		

			};  
		

		

			  
		

		

			  
		

		

			class Son : public Father   
		

		

			{  
		

		

			public:   
		

		

			    Son() {}  
		

		

			    void fun()   
		

		

			    {  
		

		

			        cout << "Son call function!" << endl;   
		

		

			    }  
		

		

			};  
		

		

			  
		

		

			void print(GrandFather* father)   
		

		

			{  
		

		

			    father->fun();  
		

		

			}  
		

		

			  
		

		

			int _tmain(int argc, _TCHAR* argv[])   
		

		

			{  
		

		

			    Father * pfather = new Son;   
		

		

			    pfather->fun();  
		

		

			    GrandFather * pgfather = new Father;   
		

		

			    print(pgfather);  
		

		

			    return 0;   
		

		

			}  
		

	

class GrandFather  
{  
public:  
    GrandFather() {}  
    virtual void fun()  
    {  
        cout << "GrandFather call function!" << endl;  
    }  
  
    ~GrandFather()   
    {  
        cout << "GrandFather destruction!" << endl;  
    }  
};  
  
class Father : public GrandFather  
{  
public:  
    Father() {}  
    void fun()  
    {  
        cout << "Father call function!" << endl;  
    }  
  
    ~Father()  
    {  
        cout << "Father destruction!" << endl;  
    }  
};  
  
  
class Son : public Father  
{  
public:  
    Son() {}  
    void fun()  
    {  
        cout << "Son call function!" << endl;  
    }  
  
     ~Son()  
    {  
        cout << "Son destruction!" << endl;  
    }  
};  
  
void print(GrandFather* p)  
{  
    p->fun();  
}  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    Father * pfather = new Son;  
    delete pfather;  
    return 0;  
}  

class GrandFather  
{  
public:  
    GrandFather() {}  
    virtual void fun() = 0  
    {  
        cout << "GrandFather call function!" << endl;  
    }  
  
    virtual ~GrandFather()   
    {  
        cout << "GrandFather destruction!" << endl;  
    }  
};  

• 纯虚函数为后代类提供可覆盖的接口，但这个类中的版本决不会调用。
• 含有（或继续）一个或多个纯虚函数的类是抽象基类，抽象基类不能实例化！
• 继承类只有重写这个接口才能被实例化

class GrandFather  
{  
public:  
    GrandFather() {}  
    void fun()  
    {  
        cout << "GrandFather call function!" << endl;  
    }  
  
    virtual ~GrandFather()   
    {  
        cout << "GrandFather destruction!" << endl;  
    }  
};  
  
class Father1 : public GrandFather  
{  
public:  
    Father1() {}  
    void fun()  
    {  
        cout << "Father call function!" << endl;  
    }  
      
};  
  
class Father2 : public GrandFather  
{  
public:  
    Father2() {}  
    void fun()  
    {  
        cout << "Father call function!" << endl;  
    }  
  
};  
  
  
class Son : public Father1, public Father2  
{  
public:  
    Son() {}  
    //void fun()  
    //{  
    //  cout << "Son call function!" << endl;  
    //}  
};  
  
void print(GrandFather* p)  
{  
    p->fun();  
}  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    Son* son = new Son;  
    son->fun();  
    return 0;  
}  

class classA  
{  
 public:  
    classA()  
    {  
        clear();  
    }  
    virtual ~classA()  
    {  
    }  
    void clear()  
    {  
        memset(this , 0 , sizeof(*this));  
    }  
    virtual void func()  
    {  
        printf("func\n");  
    }  
};  
  
class classB : public classA  
{  
};  
  
int main(void)  
{  
    classA oa;  
    classB ob;  
    classA * pa0 = &oa;  
    classA * pa1 = &ob;  
    classB * pb = &ob;  
    oa.func(); // 1  
    ob.func(); // 2  
    pa0->func(); // 3  
    pa1->func(); // 4  
    pb->func(); // 5  
    return 0;  
}  

memset(this , 0 , sizeof(*this));  

class MyClass   //没有使用explicit关键词，默认为隐式声明
{
public:
    int m_size;
    char *m_pStr;
 
    MyClass(int size)                  //没有使用explicit关键词，默认为隐式声明
    {
        m_size = size;                        //大小
        m_pStr = (char *)malloc(size + 1);    //给m_pstr 分配size的大小的内存
        memset(m_pStr, 0, size + 1);
    }
 
    MyClass(const char *pStr)            //没有使用explicit关键词，默认为隐式声明
    {
        m_size = strlen(pStr);
        m_pStr = (char *)malloc(m_size + 1); //给m_pstr分配内存
        strcpy(m_pStr, pStr);          //复制内容
    }
 
    MyClass(int size, const char *pStr)       //参数为两个，所以不管是否使用explicit关键字，都是无效的。
    {
        m_size = size;
        int size1 = strlen(pStr);             //大小
        m_pStr = (char *)malloc(size1 + 1); //给m_pstr分配内存
        strcpy(m_pStr, pStr);
    }
 
};

    MyClass c1(10);        // ok, 显式调用 MyClass(int size)
    MyClass c2 = 12;        // ok, 隐式调用 MyClass(int size)
    MyClass c3;          // 错误, 没有响应的构造函数
    MyClass c4("hello");     // ok, 显式调用 MyClass(const char *pStr)
    MyClass c5 = "nihao";   // ok, 隐式调用
    MyClass c6(5, "hello");    // ok, 显式调用 MyClass(int size, const char *pStr)
 
    c1 = 5;          // ok, 隐式调用 MyClass(int size)
    c2 = 6;           // ok, 隐式调用 MyClass(int size)
    c4 = "hello world";    // ok, 隐式调用 MyClass(const char *pStr)
 
    c3 = c1;           // 错误， 编译是没问题的，但是必须在类里重载“=”运算符才行

class MyClass
{
public:
    int m_size;
    char *m_pStr;
 
    explicit MyClass(int size)
    {
        m_size = size;                //大小
        m_pStr = (char *)malloc(size + 1);    //给m_pstr 分配size的大小的内存
        memset(m_pStr, 0, size + 1);
    }
 
    explicit MyClass(const char *pStr)
    {
        m_size = strlen(pStr);
        m_pStr = (char *)malloc(m_size + 1);   //给m_pstr分配内存
        strcpy(m_pStr, pStr);                //复制内容
    }
 
    explicit MyClass(int size, const char *pStr)  //两个参数，所以添加explicit是无效的。
    {
        m_size = size;
        int size1 = strlen(pStr);             //大小
        m_pStr = (char *)malloc(size1 + 1);   //给m_pstr分配内存
        strcpy(m_pStr, pStr);
    }
 
};

  explicit MyClass(int size, const char *pStr = "hello")
    {
        m_size = size;
        int size1 = strlen(pStr);            //大小
        m_pStr = (char *)malloc(size1 + 1);  //给m_pstr分配内存
        strcpy(m_pStr, pStr);
    }