C++类的默认构造函数

如何使用构造函数的默认参数

有这样一个类，希望使用构造函数的默认参数，应该如何使用呢？

class IntArray {
public:
    explicit IntArray(int sz = DefaultArraySize);
}

• 带括号

IntArray inta0() ;

• 不带括号

IntArray inta1;

在vs2019下，不带括号才可以正常运行。
如果类的定义是这样的：

class testclass{
public:
    int a;
}

使用定义

testclass tc0;

得到最终的tc0.a的值明显是一个乱码，是内存中的随机值。
但是使用定义

testclass tc1();

tc0.a = 0;

new一个对象加括号与不加括号的区别

默认构造函数语法小结

在定义类的时候，不带括号的定义方法是调用用户自定义的构造函数，带括号的定义方法是调用系统确定的默认构造函数。

1. 如果用户自定义了构造函数和默认构造函数（不需要任何参数就可以执行的构造函数）
   那么带括号的话，就是在编译的时候问系统：“我有一个默认构造函数，你有一个默认构造函数，你选哪个构造函数呢？”
   对于vs2019的v142编译器来说，两个都不选，在编译的时候爆出一个warning，然后不编译这个语句。

2. 如果用户没有自定义默认构造函数
   那么带括号的话，就调用系统为我们准备好的默认构造函数（一般就只是把类的成员变量赋值为0）。
   不带括号调用的也是用户自定义的构造函数（虽然我们没有定义），也可以编译运行成功，函数什么的都可以访问，但是变量的初始值就是一个乱码了。

默认构造函数用法小结

• 只自定义1个默认构造函数（大雾）
  1. 如果直接定义类的实例，使用如下可以调用自定义的构造函数

类名 变量名

使用如下无法编译：

类名 变量名()

2. 使用指针+new的方式创建对象的实例，两者方法均会调用自定义的构造函数

类名 *变量名= new 类名
类名 *变量名= new 类名()

3. 为了统一，如果想要使用自定义的默认构造函数，在指针和非指针的情况下都不要使用()

• 没有自定义构造函数
  也推荐使用不带括号的，虽然可能变量没有被系统初始化为0，但是也还好吧。。。
  如果希望一开始变量就是想要的值，为什么不好好填写构造函数的参数呢...

附件

1. my_class.h

/**
* @file my_class.h
* @brief 定义了一些用于测试的类
* @details 
*/

#ifndef __MY_CLASS__
#include
#include
/**
* @brief easy_class 只有属性没有操作
* @details 由于没有定义构造函数，所以系统使用默认的构造函数：让所有的变量为0

*/
class easy_class {
public :
    int a;///< a是一个public变量
    int b;///< a是一个public变量
    void Printa() { std::cout << "我的a是 "<a << std::endl; }

private:
    int c;///< c是一个private变量
};

/**
* @brief 增加了构造函数与析构函数
* @details 所以与easy_class相比，没有把所有变量赋值为0的操作

*/
class condecon_class {
public:
    int a;///< a是一个public变量
    int b;///< a是一个public变量
    condecon_class() { this->a = 1; this->b = 1; this->c = 1; std::cout << "construct" << std::endl; }
    ~condecon_class() { std::cout << "destruct" << std::endl; }
private:
    int c;///< c是一个private变量
};


class IntArray {
public:
    explicit IntArray(int sz = DefaultArraySize);
    IntArray(int* array, int array_size);
    IntArray(const IntArray& rhs);
    //IntArray(void);
    ~IntArray() { delete[]this->ia; }
    bool operator == (const IntArray&) const;
    bool operator != (const IntArray&)const;
    IntArray& operator =(const IntArray&);
    int& operator[] (int index);

    int size() const;
    void sort();
    int min() const;
    int max() const;
    int find(int value)const;
private:
    static const int DefaultArraySize = 12;
    int _size;
    int* ia;
    void init(int* _array, int sz);



};

#else 

#endif

2. my_class.cpp

/**
* @file my_class.cpp
* @brief 定义了一些用于测试的类
* @details 
*/
#include"my_class.h"

IntArray::IntArray(int sz)
{
    init(0, sz);
}
IntArray::IntArray(int* _array, int array_size) 
{
    init(_array,array_size);
}

/**
* @brief 传入一个IntArray的引用，将传入的IntArray拷贝一份过来
* @details 
* @param [in] rhs const IntArray&类型

* @return
*        @retval IntArray 成功
         @retval else 失败
* @note 1. 同一个类之间可以互相访问私有变量！！！
* @note 2. 引用时一种没有指针语法的指针
*/

IntArray::IntArray(const IntArray& rhs)
{
    this->_size = rhs._size;
    this->ia = new int[this->_size];
    memcpy(this->ia, rhs.ia, sizeof(int) * this->_size);// 同一个类之间可以互相访问私有变量
}

///**
//* @brief 新增的默认构造函数，原来的默认构造函数为IntArray(int sz = DefaultArraySize)
//* @details 默认构造函数只可以有一个！！！
//
//
//* @return
//*        @retval void
//       @retval else 失败
//
//
//*/
//IntArray::IntArray(void)
//{
//  std::cout << "使用构造函数IntArray::IntArray(void)" << std::endl;
//  init(0, this->DefaultArraySize);
//}


void IntArray::init(int* _array, int sz)
{
    this->_size = sz;
    this->ia = new int[this->_size];
    if (_array == 0)
        memset(this->ia, 0, sizeof(int) * sz);
    else
        memcpy(this->ia, _array, this->_size);// 同一个类之间可以互相访问私有变量
}
int& IntArray::operator[](int index)
{
    assert(index >= 0 && index < this->_size);
    return ia[index];
}