C++第一章定义构造函数

最新推荐文章于 2023-10-05 16:58:47 发布

杜甲同学

最新推荐文章于 2023-10-05 16:58:47 发布

阅读量1k

点赞数

分类专栏： C/C++ 文章标签： CC++ 构造函数析构函数

本文链接：https://blog.csdn.net/qqMCY/article/details/9196311

版权

C/C++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

//C++程序结构

//main.cpp 包含主函数的程序文件

//.h文件用户自定义的各种类的头文件，建议一个.h文件中只说明一种类。

//.cpp 用户自定义各种类的实现文件。

//构造函数是一种能够自定初始化对象的特殊成员函数。

//构造函数是和类同名的成员函数

接下来，我们定义一个Clock类

Clock.h：

#include <iostream>
class Clock {
                                                                                                                                                                                                                                                                                                                                                               
public:
                                                                                                                                                                                                                                                                                                                                                               
private:
    int m_Second;
    int m_Minute;
    int m_Hour;
                                                                                                                                                                                                                                                                                                                                                               
public:
    //Clock();就是构造函数
    Clock();
                                                                                                                                                                                                                                                                                                                                                             
    void PrintTimes();
                                                                                                                                                                                                                                                                                                                                                               
};
#endif /* defined(__C1__Clock__) */

Clock.cpp:

#include "Clock.h"
using namespace std;
Clock::Clock()
{
    std::cout<<"调用了构造函数"<<endl;
    m_Hour = 0;
    m_Minute = 0;
    m_Second = 0;
}
void Clock::PrintTimes()
{
    std::cout<<m_Hour<<":"<<m_Minute<<":"<<m_Second<<endl;
}

接下来是main函数：

int main(int argc, const char * argv[])
{
    //当程序执行到下一行语句时，程序为对象clockVar分配内存空间，然后调用不带参数的构造函数来初始化对象的成员变量，
    Clock clockVar;
    //最后程序调用成员函数PrintTimes
    clockVar.PrintTimes();
                                                                                                                                                                                                                                                                                                                     
    return 0;
}

代码例子： "构造函数和析构函数.zip" http://vdisk.weibo.com/s/G9afa

这样，我们就对构造函数有了一个初步的认识。接下来我们继续学习构造函数和运算符new

我们继续使用之前的例子。main函数如下

int main(int argc, const char * argv[])
{
    //当使用new创建一个动态对象时，new首先分配足以保存Clock类的一个对象所需的内存空间，然后自动调用构造函数来进行初始化这块内存，最后返回这个对象的地址。
    cout<<"In main()"<<endl;
    Clock* pObj = new Clock();
    cout<<"Object array"<<endl;
    Clock* pArray = new Clock[5];
    //当使用new创建一个对象或数组时，在使用完后需要用delete进行空间的释放。
    delete pObj;
    //delete [] 用来释放创建的数组对象
    delete [] pArray;
    return 0;
}

代码下载地址：http://vdisk.weibo.com/s/G9jqI

接下来，我们继续学习带参数的构造函数

Clock.h文件内容如下：

class Clock {
    
private:
    int m_Second;
    int m_Minute;
    int m_Hour;
    
public:
   //带参数的构造函数  下面的参数可以省略，也可以前后不一致，仔细对比一下就可以发现。 
    Clock(int =0,int = 0,int b=0);

};

Clock.cpp如下：

using namespace std;
Clock::Clock(int _iSecond,int _iMinute,int _iHour)
{
    cout<<"初始化"<<_iHour<<":"<<_iMinute<<":"<<_iSecond<<endl;
    m_Second = _iSecond;
    m_Minute = _iMinute;
    m_Hour = _iHour;
}

main函数如下：

using namespace std;
int main(int argc, const char * argv[])
{

    cout<<"开始"<<endl;
    Clock clockA;
    Clock clockB(10,20,21);
    
    return 0;
}

代码下载地址： http://vdisk.weibo.com/s/GaSKY

我们继续学习重载构造函数：

Clock.h文件如下：

#include <iostream>

class Clock {
    
private:
    int m_Second;
    int m_Minute;
    int m_Hour;
    
public:
    //Clock();就是构造函数
    Clock();
    
    //函数重载就是方法名相同但参数不同，因此就是不同的方法。之间没有其他的关系除了名字相同以外
    Clock(int ,int ,int );
  
    
};

Clock.cpp文件如下：

using namespace std;
Clock::Clock()
{
    std::cout<<"初始化：调用了不带参数的构造函数  "<<endl;
    m_Hour = 0;
    m_Minute = 0;
    m_Second = 0;
}

Clock::Clock(int _iSecond,int _iMinute,int _iHour)
{
    cout<<"初始化：调用了带参数的构造函数"<<_iHour<<":"<<_iMinute<<":"<<_iSecond<<endl;
    m_Second = _iSecond;
    m_Minute = _iMinute;
    m_Hour = _iHour;
}

main函数如下：

#include "Clock.h"
int main(int argc, const char * argv[])
{
    //这种初始化的方式就是直接声明一个Clock类的对象。 它会自动调用析构方法。
    Clock clockA;
    Clock clockB(12,23,43);
    return 0;
}

代码下载地址： http://pan.baidu.com/share/link?shareid=2813300908&uk=3189484501

我们来学习析构函数：

//析构函数的作用：用于在对象注销时执行一些清理工作。

//注意：调用析构函数的顺序，是和构造函数的顺序相反的，即先建立的对象最后被析构。

Clock.h文件如下：

#include <iostream>

class Clock {
    
private:
    int m_Second;
    int m_Minute;
    int m_Hour;
    
public:
    //Clock();就是构造函数
    Clock();
    //~Clock();就是析构函数
    ~Clock();
    
    //函数重载就是方法名相同但参数不同，因此就是不同的方法。之间没有其他的关系除了名字相同以外
    Clock(int,int,int);
};

Clock.cpp文件如下：

#include "Clock.h"
using namespace std;
Clock::Clock()
{
    std::cout<<"初始化：调用了不带参数的构造函数  "<<endl;
    m_Hour = 0;
    m_Minute = 0;
    m_Second = 0;
}
Clock::~Clock()
{
    cout<<"析构函数："<<m_Hour<<":"<<m_Minute<<":"<<m_Second<<endl;
}

Clock::Clock(int _iSecond,int _iMinute,int _iHour)
{
    cout<<"初始化：调用了带参数的构造函数"<<_iHour<<":"<<_iMinute<<":"<<_iSecond<<endl;
    m_Second = _iSecond;
    m_Minute = _iMinute;
    m_Hour = _iHour;
}

main函数：

#include "Clock.h"
//析构函数的作用：用于在对象注销时执行一些清理工作。
//注意：调用析构函数的顺序，是和构造函数的顺序相反的，即先建立的对象最后被析构。


int main(int argc, const char * argv[])
{

    Clock clockA;
    Clock clockB(12,23,43);
    return 0;
}

//Clock clockA; 这种初始化的方式就是直接声明一个 Clock 类的对象。它会自动调用析构方法。

代码下载地址： http://pan.baidu.com/share/link?shareid=2927544745&uk=3189484501

接下来们学习析构函数和delete

Clock.h

#include <iostream>

class Clock {
    
private:
    int m_Second;
    int m_Minute;
    int m_Hour;
    
public:
    //Clock();就是构造函数
    Clock();
    ~Clock();    
    //函数重载就是方法名相同但参数不同，因此就是不同的方法。之间没有其他的关系除了名字相同以外
    Clock(int,int,int);
};

Clock.cpp

using namespace std;

Clock::Clock()
{
    std::cout<<"初始化：调用了不带参数的构造函数  "<<endl;
    m_Hour = 0;
    m_Minute = 0;
    m_Second = 0;
}
Clock::~Clock()
{
     cout<<"析构函数："<<m_Hour<<":"<<m_Minute<<":"<<m_Second<<endl;
}

Clock::Clock(int _iSecond,int _iMinute,int _iHour)
{
    cout<<"初始化：调用了带参数的构造函数"<<_iHour<<":"<<_iMinute<<":"<<_iSecond<<endl;
    m_Second = _iSecond;
    m_Minute = _iMinute;
    m_Hour = _iHour;
}

main函数

#include "Clock.h"
using namespace std;

int main(int argc, const char * argv[])
{
    //指针需要手动调用delete方法，才能将内存释放。  
    Clock* clockA = new Clock(10,4,12);
    
    Clock* clockB = new Clock[4];
    Clock tempA;
    //指针相对于类型对象的优势，在于占用内存的空间上。
    cout<<"指针占用的内存空间"<<sizeof(clockA)<<endl;
    cout<<"类型对象占用的内存空间"<<sizeof(tempA)<<endl;
    
    delete clockA;
    delete [] clockB;
    return 0;
}

代码下载地址：http://pan.baidu.com/share/link?shareid=752461709&uk=3189484501

本文出自 “7087095” 博客，请务必保留此出处http://7097095.blog.51cto.com/7087095/1223504