C++构造

最新推荐文章于 2024-05-04 17:57:17 发布
最新推荐文章于 2024-05-04 17:57:17 发布
阅读量527 收藏 5
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41907714/article/details/117844792
版权

C++ 构造函数

  1. 默认构造函数
  2. 普通构造函数
  3. 复制构造函数
  4. 移动构造函数
  5. 转换构造函数

1. 默认构造函数

  • 什么是默认构造函数？没有参数或者所有参数都有默认值的构造函数。
  • 如果类没有定义任何构造函数，编译器会提供一个默认构造函数。
  • 如果定义了非默认构造函数，而不显式定义默认构造函数，则编译器会自动禁用默认构造函数，此时创建未经初始化的对象(实例)的语句会引发编译器错误。
  • 通常情况下，不要显式定义默认构造函数，这种做法是禁止用户创建未初始化的对象。
#include <iostream>
using std::cout;
using std::endl;

class tString
{
private:
    char *m_str;

public:
    /**
     * @brief  默认构造函数
     * @note   没有参数或者所有参数都有默认值的构造函数，称为默认构造函数
     *         作用： 
     *              定义了默认构造函数后，允许创建未经初始化的对象(实例)，
     *              如 tString ts; // 如果没定义默认构造函数，这句代码会引发编译器报错
     */
    //tString();
};

//tString::tString() {}

int main()
{
    // 把所有构造函数注释掉等价于未定义任何构造函数，此时以下语句是合法的，因为编译器提供了默认构造函数
    tString ts;

    return 0;
}

class tString
{
private:
    char *m_str;

public:
    /**
     * @brief  默认构造函数
     * @note   没有参数或者所有参数都有默认值的构造函数，称为默认构造函数
     *         作用： 
     *              定义了默认构造函数后，允许创建未经初始化的对象(实例)，
     *              如 tString ts; // 如果没定义默认构造函数，这句代码会引发编译器报错
     */
    // tString();

    /**
     * @brief  非默认构造函数
     * @note   定义非默认构造函数之后，如果不显式定义默认构造函数，不允许创建未经初始化的对象(实例)
     *         如 tString ts; // 触发编译器错误
     * 
     * @param  src              - 
     * @param  len              - 
     */
    tString(const char *src, int len);

};

// tString::tString() {}

tString::tString(const char *src, int len) : m_str(new char[len + 1]) {}

int main()
{
    // 此时该语句触发编译器错误，但如果将默认构造函数解注释，则可通过编译
    tString ts;

    return 0;
}

2. 普通构造函数

3. 复制构造函数

  • 复制构造函数/拷贝构造函数通常用于“左值复制”。
#include <iostream>
#include <string.h>    // C standard lib

using std::cout;
using std::endl;

class tString
{
private:
    char *m_str;
    int   m_len;

public:

    /**
     * @brief  非默认构造函数
     */
    tString(const char *src, int len) : m_len(len), m_str(new char[len + 1]) 
    {
        for (int i = 0; i < m_len; i++)
        {
            m_str[i] = src[i];
        }

        m_str[m_len] = '\0';
        cout << "general constructor." << endl;
    }

    /**
     * @brief       复制构造函数/拷贝构造函数
     * @note        C++默认的复制构造函数只进行“浅拷贝”，自己实现复制构造函数的目的
     *              通常都是将默认的浅拷贝转换为“深拷贝”
     * 
     * @attention   这里有个有趣的现象，复制构造函数可以访问不同对象的私有成员!!!
     * 
     * @param  _ts              - 
     */
    tString(const tString &_ts)
    {
        m_len = _ts.m_len;          // 直接访问_ts对象的私有成员变量
        m_str = new char[m_len + 1];

        char *tmp = _ts.m_str;      // 直接访问_ts对象的私有成员变量
        int     i = 0;
        while(*tmp)
        {
            m_str[i] = *tmp;
            i++;
            tmp++;
        }

        m_str[m_len] = '\0';

        cout << "copy constructor called." << endl;
    }

    ~tString() 
    {
        if (m_str)
        {
            delete[] m_str;
        }

        cout << "destructor called." << endl;
    }
    
    void showAddr()
    {
        cout << (void *)m_str << endl;
    }

};

tString testCopyTime(tString ts1)
{
    return ts1;
}

int main()
{
    char src[20] = "Hello, world.";

    tString ts1 = tString(src, strlen(src));
    
    tString ts2 = ts1;

    ts1.showAddr();
    ts2.showAddr();

    // 为了测试不适用左值引用作为形参，以及返回临时对象时，复制构造函数被调用的次数
    // 根据gdb调试，调用testCopyTime函数会调用两次复制构造函数，同一份数据会在一瞬间存在于三个对象中(三份拷贝)
    tString ts3 = testCopyTime(ts2);

    return 0;
}

# 打印结果
general constructor.      # ts1对象构建时调用一般构造函数
copy constructor called.  # ts2对象构建时调用复制构造函数               
0xeb6fd0                  # 使用自定义复制构造函数进行深拷贝，ts1和ts2内容一致，但是内部指针指向两个不同的内存块
0xeb6fe8                 
copy constructor called.  # 调用testCopyTime()创建形参变量时调用复制构造函数一次
copy constructor called.  # testCopyTime()赋值给返回值时，触发复制构造函数一次，调用一次testCopyTime触发两次复制构造函数！！
destructor called.                                                                                  destructor called.                                                                              destructor called.                                                                                 destructor called.

如果把自定义的复制构造函数注释掉，c++也会提供默认的复制构造函数。

class tString
{
private:
    char *m_str;
    int   m_len;

public:

    /**
     * @brief  非默认构造函数
     */
    tString(const char *src, int len) : m_len(len), m_str(new char[len + 1])
    {
        for (int i = 0; i < m_len; i++)
        {
            m_str[i] = src[i];
        }

        cout << "general constructor." << endl;
    }

    /**
     * @brief       复制构造函数/拷贝构造函数
     * @note        C++默认的复制构造函数只进行“浅拷贝”，自己实现复制构造函数的目的
     *              通常都是将默认的浅拷贝转换为“深拷贝”
     *
     * @attention   这里有个有趣的现象，复制构造函数可以访问不同对象的私有成员!!!
     *
     * @param  _ts              -
     */
#if 0
    tString(const tString &_ts)
    {
        m_len = _ts.m_len;          // 直接访问_ts对象的私有成员变量
        m_str = new char[m_len];

        char *tmp = _ts.m_str;      // 直接访问_ts对象的私有成员变量
        int     i = 0;
        while(*tmp)
        {
            m_str[i] = *tmp;
            i++;
            tmp++;
        }

        cout << "copy constructor called." << endl;
    }
#endif

    ~tString()
    {
        if (m_str)
        {
            delete[] m_str;
        }

        cout << "destructor called." << endl;
    }

    void showAddr()
    {
        cout << (void *)m_str << endl;
    }

};

tString testCopyTime(tString ts1)
{
    return ts1;
}

int main()
{
    char src[20] = "Hello, world.";

    tString ts1 = tString(src, strlen(src));
	
    // 此语句触发的是“默认的复制构造函数”，而自定义的复制构造函数被注释掉了
    tString ts2 = ts1;

    ts1.showAddr();
    ts2.showAddr();

    // 为了测试不适用左值引用作为形参，以及返回临时对象时，复制构造函数被调用的次数
    // 根据gdb调试，调用testCopyTime函数会调用两次复制构造函数，同一份数据会在一瞬间存在于三个对象中(三份拷贝)
    //tString ts3 = testCopyTime(ts2);

    return 0;

# 打印结果
general constructor.                                                                                 0xee6fd0                                                                                             0xee6fd0                                                                                             destructor called.                                                                                   destructor called.

可以看到ts2的m_str指针和ts1的m_str指针指向同一内存处，这种情况下，当ts2和ts1析构时，就会造成***“double free”***的问题。

4. 移动构造函数

C++11引入移动语义。所谓移动，就是把原来对象A所拥有的数据转移给对象B，这种情况就像是有两颗二叉树，需要把二叉树A的一个结点移到二叉树B上，移动节点后，树A原有的结点可以置空、也可以释放。

初始状态
转移结点

在C++代码层面：

#include <iostream>
#include <string.h>    // C standard lib

using std::cout;
using std::endl;

class tString
{
private:
    char *m_str;
    int   m_len;

public:
    /**
     * @brief  默认构造函数
     */
    // tString() : m_str(nullptr), m_len(0) {}

    /**
     * @brief  非默认构造函数
     */
    tString(const char *src, int len) : m_len(len), m_str(new char[len + 1]) 
    {
		// ..
    }

    /**
     * @brief       复制构造函数/拷贝构造函数
     */
    tString(const tString &_ts)
    {
        // ...
    }

    /**
     * @brief  移动构造函数
     * @param  ts_              - 
     */
    tString(tString &&ts_) : m_len(ts_.m_len), m_str(ts_.m_str)
    {
        // 为了防止double free，将ts_源对象的值置空
        ts_.m_str = nullptr;
        ts_.m_len = 0;

        cout << "Move constructor called." << endl;
    }

    ~tString() 
    {
        if (m_str)
        {
            delete[] m_str;
        }

        cout << "destructor called." << endl;
    }
    
    void showAddr()
    {
        cout << (void *)m_str << endl;
    }

};

int main()
{
    char src[20] = "Hello, world.";

    tString ts3 = tString(src, strlen(src));

    // 触发移动构造函数：三种方式
    ts3.showAddr();

    // 方式1 - 强制类型转换
    tString ts4 = tString(static_cast<tString &&>(ts3));
    ts3.showAddr();
    ts4.showAddr();

    // 方式2 - std::move()
    tString ts5 = std::move(ts4);
    ts4.showAddr();
    ts5.showAddr();

    // 方式三，重载+/=等运算符，使其支持移动语义

    return 0;
}

移动构造函数中使用到**右值引用作为形参，要点是如果源对象有指针成员，转移后，需置空源对象指针，否则容易导致double free。

5. 转换构造函数 - 单参构造函数

#include <iostream>
#include <string.h>    // C standard lib

using std::cout;
using std::endl;

class tString
{
private:
    char *m_str;
    int   m_len;

public:
    /**
     * @brief  默认构造函数
     */
    // tString() : m_str(nullptr), m_len(0) {}

    /**
     * @brief  非默认构造函数
     */
    tString(const char *src, int len) : m_len(len), m_str(new char[len + 1]) 
    {
		// ...
    }

    /**
     * @brief  转换构造函数/单参构造函数
     * @note   主要作用由两点：
     *              1. tString对象仅需初始化单个参数
     *              2. 作为类型转换，如将int转换为tString
     * @param  num              - 
     */
    explicit tString(int num) : m_str(nullptr), m_len(num)
    {
        // 这里并没有作类型转换，简单例子

        cout << "type convert constructor called." << endl;
    }

    /**
     * @brief       复制构造函数/拷贝构造函数
     */
    tString(const tString &_ts)
    {
		// ...
    }

    /**
     * @brief  移动构造函数
     * @param  ts_              - 
     */
    tString(tString &&ts_) : m_len(ts_.m_len), m_str(ts_.m_str)
    {
		// ...
    }

    ~tString() 
    {
        if (m_str)
        {
            delete[] m_str;
        }

        cout << "destructor called." << endl;
    }
    
    void showAddr()
    {
        cout << (void *)m_str << endl;
    }

};

tString testCopyTime(tString ts1)
{
    return ts1;
}

int main()
{
    tString ts6(100);

    return 0;
}

6.构造函数的显式(explicit)和隐式(implicit)

加了explicit关键字的构造函数，只能被显式调用，而且***一般只用于修饰单参构造函数***，可以禁止编译器执行非预期的类型隐式转换。

7. 构造函数小结

  • 复制构造函数应当保证每一个对象实例化时，都拥有自己独立的内存地址，不与其他对象共享内存地址，避免double free or multiple free。
  • 移动构造函数实际上是同一个内存地址空间换了个对象表示，但必须把源对象的指针/引用置空，也是为了防止double free。

C++深复制和浅复制

1. 什么是深拷贝、浅拷贝（什么是深复制、浅复制）？

深拷贝

浅拷贝

2. 深拷贝和浅拷贝的区别

  • 对于基本类型数据(非指针、非引用)，深拷贝和浅拷贝效果基本一致
  • 但当对象中含有指针、引用时，如果使用浅拷贝，会导致多个对象中的指针指向同一块内存空间，当对象析构时，会对同一地址多次delete，造成***“double free or multiple free”***。
  • 如果使用深拷贝，每一个对象中的指针/引用都指向独立的内存空间，于是避免了"对同一地址多次delete"的问题。

完整地练习源码

#include <iostream>
#include <string.h>    // C standard lib

using std::cout;
using std::endl;

class tString
{
private:
    char *m_str;
    int   m_len;

public:
    /**
     * @brief  默认构造函数
     * @note   没有参数或者所有参数都有默认值的构造函数，称为默认构造函数
     *         作用： 
     *              定义了默认构造函数后，允许创建未经初始化的对象(实例)，
     *              如 tString ts; // 如果没定义默认构造函数，这句代码会引发编译器报错
     */
    // tString() : m_str(nullptr), m_len(0) {}

    /**
     * @brief  非默认构造函数
     * @note   定义非默认构造函数之后，如果不显式定义默认构造函数，不允许创建未经初始化的对象(实例)
     *         如 tString ts; // 触发编译器错误
     * 
     * @param  src              - 
     * @param  len              - 
     */
    tString(const char *src, int len) : m_len(len), m_str(new char[len + 1]) 
    {
        for (int i = 0; i < m_len; i++)
        {
            m_str[i] = src[i];
        }

        m_str[m_len] = '\0';
        cout << "general constructor." << endl;
    }

    /**
     * @brief  转换构造函数/单参构造函数
     * @note   主要作用由两点：
     *              1. tString对象仅需初始化单个参数
     *              2. 作为类型转换，如将int转换为tString
     * @param  num              - 
     */
    explicit tString(int num) : m_str(nullptr), m_len(num)
    {
        // 这里并没有作类型转换，简单例子

        cout << "type convert constructor called." << endl;
    }

    /**
     * @brief       复制构造函数/拷贝构造函数
     * @note        C++默认的复制构造函数只进行“浅拷贝”，自己实现复制构造函数的目的
     *              通常都是将默认的浅拷贝转换为“深拷贝”
     * 
     * @attention   这里有个有趣的现象，复制构造函数可以访问不同对象的私有成员!!!
     * 
     * @param  _ts              - 
     */
    tString(const tString &_ts)
    {
        m_len = _ts.m_len;          // 直接访问_ts对象的私有成员变量
        m_str = new char[m_len + 1];

        char *tmp = _ts.m_str;      // 直接访问_ts对象的私有成员变量
        int     i = 0;
        while(*tmp)
        {
            m_str[i] = *tmp;
            i++;
            tmp++;
        }

        m_str[m_len] = '\0';

        cout << "copy constructor called." << endl;
    }

    /**
     * @brief  移动构造函数
     * @param  ts_              - 
     */
    tString(tString &&ts_) : m_len(ts_.m_len), m_str(ts_.m_str)
    {
        // 为了防止double free，将ts_源对象的值置空
        ts_.m_str = nullptr;
        ts_.m_len = 0;

        cout << "Move constructor called." << endl;
    }

    ~tString() 
    {
        if (m_str)
        {
            delete[] m_str;
        }

        cout << "destructor called." << endl;
    }
    
    /**
     * @brief  重载赋值运算符，支持深拷贝
     * @param  ts_              - 
     * @return tString&         - 
     */
    tString & operator=(const tString &ts_)
    {
        // 如果是将自己赋值给自己
        if (this == &ts_)
        {
            return *this;
        }

        delete[] m_str;

        m_len = ts_.m_len;

        m_str = new char[m_len + 1];

        int i = 0;
        while (i < m_len)
        {
            m_str[i] = ts_.m_str[i];
            i++;
        }

        m_str[m_len] = '\0';

        cout << "copy assigned function called." << endl;
    }

    /**
     * @brief  支持移动语义的赋值运算符重载
     * @param  ts_              - 
     * @return tString&         - 
     */
    tString & operator=(tString &&ts_)
    {
        if (this == &ts_)
        {
            return *this;
        }

        delete[] m_str;

        m_len = ts_.m_len;
        m_str = ts_.m_str;

        ts_.m_len = 0;
        ts_.m_str = nullptr;

        return *this;

        cout << "move assign function called." << endl;
    }

    void showAddr()
    {
        cout << (void *)m_str << endl;
    }

    void val()
    {
        cout << m_str << endl;
    }
};

tString testCopyTime(tString ts1)
{
    return ts1;
}

int main()
{
    char src[20] = "Hello, world.";

    tString ts1 = tString(src, strlen(src));
    ts1.val();

    tString ts2 = ts1;

    ts1.showAddr();
    ts2.showAddr();
    ts2.val();

    tString ts3 = testCopyTime(ts2);

    // 触发移动构造函数：三种方式
    ts3.showAddr();
    ts3.val();

    // 方式1 - 强制类型转换
    tString ts4 = tString(static_cast<tString &&>(ts3));
    ts3.showAddr();
    ts4.showAddr();

    // 方式2 - std::move()
    tString ts5 = std::move(ts4);
    ts4.showAddr();
    ts5.showAddr();

    // 方式三，重载+/=等运算符，使其支持移动语义


    tString ts6(100);

    ts6 = tString(src, strlen(src));
    ts6.showAddr();

    return 0;
}

不知不觉已经工作快一年了，好久没有写过博客，再次记录一下本周学习，偷得浮生半日闲，又摘桃花换酒钱，纯属个人笔记，如有错误，欢迎大佬讨论！！！

码路上的江小白
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++编程笔记：详细讲解丨C++中的构造方法
致力于C语言C++知识分享！
04-22 957
什么是构造函数？ 构造函数是类的成员函数，用于初始化类的对象。在C ++中，创建对象（类的实例）时会自动调用Constructor。它是该类的特殊成员函数。 构造函数与普通成员函数有何不同？ 构造函数与普通函数在以下方面有所不同： 构造函数与类本身具有相同的名称 构造函数没有返回类型 创建对象时会自动调用构造函数。 如果不指定构造函数，则C ++编译器会为我们生成一个默认构造函数（不带参数，并且具有空主体）。 让我们通过一个真实的例子来了解C ++中构造函数的类型： 假设您去商店买了.
C++构造函数
安安的博客
05-24 8856
类的6个默认成员函数 如果我们写了一个类，这个类我们只写了成员变量没有定义成员函数，那么这个类中就没有函数了吗？并不是的，在我们定义类时即使我们没有写任何成员函数，编译器会自动生成下面6个默认成员函数。 class S { public: int _a; }; 这里就来详细介绍一下构造函数。 构造函数 使用C语言，我们用结构体创建一个变量时，变量的内容都是随机值，要想要能正确的操作变量中存储的数据，我们还需要调用对应的初始化函数，给成员变量赋一个合适的初值。那么C++呢，我们仍然使用这个方法来试试。
C++构造函数的各种用法全面解析（C++初学面向对象编程）
Viewinfinitely的博客
03-21 5万+
类和对象是 C++ 的重要特性，它们使得 C++ 成为面向对象的编程语言。在C++类的学习当中，有一个用来初始化成员数据的函数即构造函数，本文重点分析的就是构造涵的各种用法和注意事项。
c++类——构造函数
xiaohei07的博客
07-11 2071
如有兴趣了解更多请关注我的个人博客。
C++构造函数的调用方法
最新发布
weixin_44992737的博客
05-04 452
简介：C++的构造函数用于对象的初始化，然后将初始化之后的对象赋值给一个变量。下面将要介绍调用类构造函数的几种方法。
C++技术——构造法
墨小白
09-12 747
一 构造成员函数 1 构造成员函数：如果没有声明定义自己的构造函数，自动产生默认的构造函数，函数体为空。 2 构造函数参数列表：创建对象时就初始化参数列表，而构造函数体内方法只有对象创建完成后才调用。    构造函数初始化列表初始化作用：（1）初始化成员常变量 （2）调用父类的构造法。 （2）调用父类的构造法：参数列表中调用基类的构造函数。 Derived(double dValue=0...
C++构造函数深度学习
09-01
C++构造函数是类的重要组成部分，用于在创建对象时初始化成员变量。在深入学习C++构造函数时，我们需要理解它们的工作原理以及如何有效地利用它们来优化代码。 首先，让我们回顾一下构造函数的基本概念。在C++中，...
C++构造函数的调用顺序
08-19
C++构造函数的调用顺序详解 C++中的构造函数调用顺序是一个非常重要的概念，它决定了对象的初始化顺序。本文将详细介绍C++构造函数的调用顺序，包括基类构造函数、内嵌成员对象的构造函数和派生类的构造函数体中的...
C++ 构造函数初始化列表的好处
12-22
C++ 类对像构造时，需要对类成员变量完成初始化赋值操作。使用初始化列表完成这步操作在性能上有益处。什么好处呢？摆道理显得不够彻底。看书不如做实验。让我们结合执行过程来查看。考虑如下示例代码： 　...
C++构造函数抛出异常需要注意的地方
08-18
总结起来，C++构造函数抛出异常需要谨慎处理，特别是涉及到动态内存分配时，应优先选择使用智能指针来确保内存管理的正确性。在设计构造函数时，应尽量避免异常的发生，或者在抛出异常时提供足够的上下文信息，以...
c++ 构造函数中调用虚函数的实现方法
08-31
首先，理解C++对象的构造过程至关重要。在创建一个对象时，构造函数会按照继承层次自底向上顺序执行。这意味着先调用最底层派生类的构造函数，然后逐层向上调用基类的构造函数。在每个构造函数中，对象的部分状态...
C++ 类(继承中的构造和析构)
小白的博客
07-29 1万+
文章概述 类型(赋值)兼容性原则; 类型(赋值)兼容性原则可以分为2个情况; 继承中的对象模型(内存模型); 继承中的构造析构调用原则; 继承和组合混搭下的构造和析构; 继承中同名的成员函数和成员变量处理方法; 继承中的static关键字 类型(赋值)兼容性原则 a. 类型(赋值)兼容性原则的说明: 需要基类对象的任何地方,都可以用公有派生类对象代替。通过公有继承,派生类得到了基类中...
C++ 类(构造函数和析构函数)
小白的博客
07-20 4万+
文章概述 构造函数和析构函数的由来？ 构造函数和析构函数的基本语法 C++编译器构造析构方案 PK 对象显示初始化方案 构造函数的分类以及调用 默认的构造函数 构造函数调用规则 构造函数和析构函数的总结 构造函数和析构函数的由来 类的数据成员不能在类的声明时候初始化,为了解决这个问题? 使用构造函数处理对对象的初始化。构造函数是一种特殊的成员函数,与其他函数不同,不需要用户调用它,而...
C++默认构造函数——深入理解
热门推荐
HAN Kai
09-05 6万+
错误认识1：若程序员没有自己定义无参数的构造函数，那么编译器会自动生成默认构造函数，来进行对成员函数的初始化。 错误认识2：编译器合成出来的default constructor会明确设定'“class内每一个data member的默认值”。但这两种种认识是有误的，不全面的。 正确认识： 默认的构造函数分为有用的和无用的，所谓无用的默认构造函数就是一个空函数、什么操作也不做，而有用的默
C++ 构造与析构
qq_42152125的博客
10-31 443
构造和析构 1.养成一个习惯，只要是变量，定义后要初始化 2.在C++当中要完成对象的初始化工作，可以借助构造来完成，如果要完成对象的清理操作，借助析构来完成 3.在C++里面对于对象的初始化有4种方式： 1、直接赋值（结构的直接赋值），类中数据成员全是公有，且没有声明任何的构造函数。不建议大家用 2、公有的初始化函数.(习惯写成公有的赋值函数) 3、构造函数 C++规定在类的说明中可以包含一...
C++对象的构造(中)
年少轻狂，幸福时光
07-18 578
--事物的难度远远低于对事物的恐惧！       上一章，我们简单的了解了C++ 中的构造函数，那么这节我们再来分析下C++中的构造函数，在上一节中，我们通过构造函数去初始化类对象，但是细心的朋友会发现，我们定义的三个类对象，它们的初始化值都一样，那么有没有办法使得不同类对象拥有各自的初始化值？     要解决上边的疑问，我们首先来回顾先C++中构造函数     - 无返回值，函数名与类名相同 ...
C++类实例化时的内存分配
大无赖blog
05-24 2226
初学者在学习面向对象的程序设计语言时，或多或少的都些疑问，我们写的代码与最终生编译成的代码却　大相径庭，我们并不知道编译器在后台做了什么工作．这些都是由于我们仅停留在语言层的原因，所谓语言层就是教会我们一些基本的语法法则，但不会告诉我们为什么这么做？今天和大家谈的一点感悟就是我在学习编程过程中的一点经验，是编译器这方面的一个具体功能． 首先：我们要知道什么是类的实例化，所谓类的实例化就是在内
C++——类的构造
御承扬的博客
07-02 3395
一、类的构造 1、类的声明、实现与调用： #include <C++函数库里的头文件名> #include”用户自己编写的头文件名” class 类名标识符 { 权限修饰符：为public，protected和private，权限大小public<protected<private 构造方法（类名 （参数类型 参数名）） 数据成员声明（类型 数据标识符）：int a; 成员...
在c语言中如何构造函数,C++ 构造函数
weixin_39953845的博客
05-20 1745
C++ 构造函数在本文中，您将学习C ++中的构造函数。您将学习什么是构造函数，如何创建它以及C ++中的构造函数类型。构造函数是成员函数的一种特殊类型，它在创建对象时会自动对其进行初始化。编译器通过其名称和返回类型将给定的成员函数标识为构造函数。构造函数与该类具有相同的名称，并且没有任何返回类型。同样，构造函数始终是公共的。........classtemporary{private:in...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值