C++构造函数与析构函数的一些简单总结

1.构造函数与析构函数可以是内连函数吗？

#include<iostream>
using namespace std;
class A
{
public:
    A();
    /*{
        cout<<"Constructor is called now!"<<endl;
    };*/
    ~A();
    /*{
        cout<<"Default Deconstructor is called Now!"<<endl;
    };*/
};

inline A::A(){
    cout<<"inline Constructor A is working!"<<endl;
}

inline A::~A(){
    cout<<"inline A is working Now!";
}

int main(){
    A *objA=new A();
    delete objA;
    system("pause");

    return 0;
};

2.一些大型类的基类中的析构函数往往是虚函数，为什么？

class orig{

               public：~orig();

};

class Next:orig{

              public:

                     Next(){  char *p=new char(100);};

                     ~Next(){delete []p;};

};

int main(){

             orig *objo=new orig();

             Next *objn=new Next();

             objn=&objo;

             //after do somethings,we need destruct the objo,like this;

             delete objn;              //some problem occoured!

             return 0;

}

当我们删除objn对象时，由于objn指向的是Orig类中的析构函数式非virtual的，无法完成多态性功能，即delete objn（子类）时，只调用~orig()；子类Next申请的内存未被释放，会造成内存泄漏。

3.构造函数不能是virtual型的原因？

一个类的建立或实例化，操作系统必须知道他的准确信息，而这正是构造函数要做的。与构造函数不同的是，为了实现多态性，动态的处理和销毁该类，我们可采取的措施要根据情况而定。不是所有的函数都可以virtual型，虚函数是有内存开销的，每个虚函数都有一个对应的虚函数表来维护，这些都是操作系统要付出的代价。

4.理解拷贝函数与复制函数在类中的实现与使用？

先看一个例子，String：

class String{

public：

           String(const char *str=NULL){};             //普通带参构造函数

           String(const String &copyS){};               //同类参数的拷贝构造函数

           ~String();                                             //析构函数

           String &operate = (const String &setS)   //赋值函数

 private：

           char *mdata;

};

下面就将上面的String类中的关键函数补充完整：

String::String(const char *str){                                  //普通带参构造函数

              if(str==NULL){

                   mdata= new char[1];

                   *mdata='\0';

               }

              else{

                  int len=strlen(str);

                  mdata=new char[len+1];

                  strcpy(mdata,str);

              }

};     

String::String(const String &copyS){                          //同类参数的拷贝构造函数       

                 int slength=strlen(copyS.mdata);

                 mdata= new char[slength + 1];

                 strcpy(mdata,copyS.mdata);

};             

String   &String::operte =(const String &setS){

               //检测自己是否已被setS赋值

                if(*this==setS)

                    return *this;

                delete []mdata;                             //赋值操作前先清理原有的内存资源

                int len = strlen(setS.mdata);

                this.mdata=new char[len+1];

                strcpy(this.mdata,setS.mdata);

                return *this;

}

String::~String(){

               delete []mdata;

}

这些简单的说明，或许可以给你一点关于C++中关于构造函数的思考，还有比如深浅拷贝等，则下次有机会再说。