C++中的一些基础概念及解析(含构造函数与析构函数)

1.容器

容器用来存储数据的，数据可以是用户自定义类型（对象），也可以是预定义类型。一般用的就有（vector,list,deque）那么有什么好处呐？参考这篇博客：博客

2.函数重载

什么是函数重载？（what）在同一作用域内，函数名相同但参数不同的一组函数。这组函数被称为重载函数。为什么需要它？（why）重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

代码示例在对象指针那块

参考学习：函数重载

3.对象指针

顾名思义，就是指向对象的指针，尽量初始化

代码示例：

#include<iostream>
using namespace std;
class Myclass{
    private:
    int m;
    int n;
    public:    //公有访私有
    Myclass()  //函数重载   {与下面的Myclass(int x,int y) }
    {
        m= 0;
        n=0 ;
    }
    Myclass(int x,int y){ //构造函数
        m= x;
        n = y ;
    }
    void print()
    {
        cout <<  m <<  "  " << n << endl;
    }
};
int main(void)
{
    Myclass my1(3,5),my2;
    Myclass *pmy=&my1;  //对象指针 pmy 指向了对象my1 
    pmy->print();  //通过对象指针操作对象
    pmy=&my2;
    pmy->print();
}

运行截图：

4.动态对象

其实就是程序员自己去new对象出来。

代码示例：

#include<iostream>
using namespace std;
class Myclass{
    private:
    int m;
    int n;
    public:
    Myclass()
    {
        m= 0;
        n= 0 ;
    }
    Myclass(int x,int y){
        m= x;
        n = y ;
    }
    void print()
    {
        cout <<  m <<  "  " << n << endl;
    }
};
int main(void)
{
    Myclass *pmy = new Myclass(33,55); //动态对象
    pmy->print();
    delete pmy ; //记得delete ！！ 
    pmy = NULL;  //记得把指针指空
}

运行截图：

5.this 指针

1.this指针是隐含在类中的一个指针

2. 用来指向一个类中的某一个对象

3.一个类只有一个this指针。

4.this指针可以显式使用，也可以隐式使用。

5.this指针永远指的就是当前对象，也就是目前用的对象

6.this指针在显式使用时，必须在类内使用

代码示例：

#include<iostream>
using namespace std;
class Myclass{
    private :
    int x;
    int y;
    public:
    Myclass()
    {
        x= 0 ;
        y= 0 ;
    }
    Myclass(int x,int y)
    {
        /*
         * x=x;  编译器无法正确识别是参数还是数据成员
         y= y ;
         */
        this->x= x;      //加一个this 指针
        this->y= y;
    }
    void print()
    {
        cout << x << ": "  << y << endl ;
    }
};
int main(void)
{
    Myclass my(3,5);
    my.print();
    return 0;
}

其实仔细想来this指针也是一个对象指针，只不过比较特殊一点而已（指向当前所用的对象）

6.全局对象与局部对象

说明：对应于全局变量与局部变量。在函数内用类定义的对象为局部对象。在函数外用类定义的对象为全局对象。

特点：

1.局部对象在函数运行完就释放，全局对象在整个程序运行完才释放

2.全局对象在编译时就分配单元，而局部对象在运行时分配单元。

7.构造函数与析构函数

1，构造函数

（1） 构造函数的作用是创建对象时系统自动调用构造函数，由它负责为对象进行初始化操作。比如：变量与指针的初始化，开辟线程，加锁，开辟内存等等操作。

（2）特点：

>1 ,与类同名

> 2,有参，可以重载

> 3. 表示：

    类名(){

    构造函数体;

    };

> 4. 如果在类中没有定义构造函数，系统就会自动生成一个空构造函数。

2，析构函数

(1)析构函数的作用是释放对象时系统自动为你调用析构函数，由它负责为对象进行资源销毁操作。比如：销毁线程，解锁，delete内存空间等等操作。

(2)特点：

>1 ,与类同名

> 2,无参，不能重载

> 3. 表示：

    ~类名(){

    析构函数体;

    };

> 4. 用new分配的动态对象，在释放时，系统要为该对象调用析构函数。

> 5. 如果在类中没有定义析构函数，系统就会自动生成一个空析构函数

3，代码示例：

#include<iostream>
using namespace std;
class Myclass{
    public:
    Myclass()  //构造函数
    {
        cout << "11111111"  << endl ;
    }
    ~Myclass()  //析构函数
    {
        cout << "22222222222" << endl;
    }
};

Myclass myGlobal ;  //全局对象

int main(void)
{
    cout << "The myGlobal size is " << sizeof(myGlobal) << endl;
    //                                       1个字节,8 bit 
    Myclass my1,my2;  //局部对象
    Myclass *pmy = new Myclass() ;  //new 必须加括号
    delete pmy; //释放顺序：pmy->my2->my1->myGlobal  释放前调用
    //                                           析构函数
}

运行截图：

4， 那么对于一个对象而言，它的完整顺序就是：创建对象（系统自动调用构造函数）—-> 使用对象 —-> 释放对象（系统自动调用析构函数）。想想栈哦～_～

5，其实这就牵涉到了c++的RAII机制，具体的可以自己查资料学习一下。

参考学习：这里写链接内容