如何使用构造函数的默认参数
有这样一个类，希望使用构造函数的默认参数，应该如何使用呢？
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一个对象加括号与不加括号的区别
默认构造函数语法小结
在定义类的时候，不带括号的定义方法是调用用户自定义的构造函数，带括号的定义方法是调用系统确定的默认构造函数。
如果用户自定义了构造函数和默认构造函数（不需要任何参数就可以执行的构造函数）
那么带括号的话，就是在编译的时候问系统：“我有一个默认构造函数，你有一个默认构造函数，你选哪个构造函数呢？”
对于vs2019的v142编译器来说，两个都不选，在编译的时候爆出一个warning，然后不编译这个语句。如果用户没有自定义默认构造函数
那么带括号的话，就调用系统为我们准备好的默认构造函数（一般就只是把类的成员变量赋值为0）。
不带括号调用的也是用户自定义的构造函数（虽然我们没有定义），也可以编译运行成功，函数什么的都可以访问，但是变量的初始值就是一个乱码了。
默认构造函数用法小结
- 只自定义1个默认构造函数（大雾）
- 如果直接定义类的实例，使用如下可以调用自定义的构造函数
类名 变量名
使用如下无法编译：
类名 变量名()
- 使用指针+new的方式创建对象的实例，两者方法均会调用自定义的构造函数
类名 *变量名= new 类名
类名 *变量名= new 类名()
- 为了统一，如果想要使用自定义的默认构造函数，在指针和非指针的情况下都不要使用()
- 没有自定义构造函数
也推荐使用不带括号的，虽然可能变量没有被系统初始化为0，但是也还好吧。。。
如果希望一开始变量就是想要的值，为什么不好好填写构造函数的参数呢...
附件
- my_class.h
/**
* @file my_class.h
* @brief 定义了一些用于测试的类
* @details
*/
#ifndef __MY_CLASS__
#include<cassert>
#include<iostream>
/**
* @brief easy_class 只有属性没有操作
* @details 由于没有定义构造函数，所以系统使用默认的构造函数：让所有的变量为0
*/
class easy_class {
public :
int a;///< a是一个public变量
int b;///< a是一个public变量
void Printa() { std::cout << "我的a是 "<<this->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
- 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];
}
