[C++] 类和对象

在C++中，构造函数是专门用于初始化对象的方法。当创建类的新实例时，构造函数会自动被调用。通过构造函数，我们可以确保对象在创建时就被赋予合适的初始状态。下面我将详细解释如何使用构造函数进行初始化操作，并以Date类为例进行说明。

创建一个Date类：

class Date 
{  
public:  
    // 成员函数...  
private:  
    int _year;  
    int _month;  
    int _day;  
};

构造函数的特征

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。

无参构造

无参构造函数允许我们创建Date对象而不提供任何参数。但是，需要注意的是，如果我们不在无参构造函数中初始化成员变量，那么这些变量的初始值将是未定义的，这可能会导致程序出错。
Date d1; // 调用无参构造函数

class Date 
{  
public:  
    // 1. 无参构造函数  
    Date() 
    {  
        // 在这里可以添加一些初始化代码，例如设置默认日期  
        // 例如：_year = 2000; _month = 1; _day = 1;  
    }  
  
    // 其他成员函数...  
  
private:  
    int _year;  
    int _month;  
    int _day;  
};

带参构造

带参构造可以和无参构造函数重载，因为在之后调用的时候不会受影响，可以与之后讲解的全缺省构造函数和无参构造函数之间的不能函数重载的进行区别。

带参构造函数可以在对对象进行初始化的时候进行传参，传参的数值会直接进行初始化对象中的成员变量。
Date date2(2023, 3, 15); // 调用带参构造函数创建对象，并初始化日期为2023年3月15日

class Date 
{  
public:  
    // 1. 无参构造函数  
    Date() 
    {  
        // ...  
    }  
  
    // 2. 带参构造函数  
    Date(int year, int month, int day) 
    {  
        _year = year;  
        _month = month;  
        _day = day;  
    }  
  
    // 其他成员函数...  
  
private:  
    int _year;  
    int _month;  
    int _day;  
};

在这个带参构造函数中，我们通过参数year、month和day来初始化_year、_month和_day成员变量。这样，我们就可以在创建Date对象时直接指定日期了。

注意区别创造对象的格式

Date d1; // 调用无参构造函数
Date d2(2015, 1, 1); // 调用带参的构造函数

默认无参构造函数

参考代码：

class Date
{
public:
/*
// 如果用户显式定义了构造函数，编译器将不再生成
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
*/
    void Print()
    {
    cout 
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
    数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
    生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    return 0;
}

public:
	// 显式定义的无参构造函数  
	Date() 
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
	// 其他成员函数...  
private:
	int _year;
	int _month;
	int _day;
};
  
        _year = year;  
        _month = month;  
        _day = day;  
    }
  
    _year = year;  
    _month = month;  
    _day = day;  
}

public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

public:
    Stack(size_t capacity = 3)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (nullptr == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(DataType data)
    {
        if (_size == _capacity)
        {
            // 扩展数组大小
            _capacity *= 2;
            _array = (DataType*)realloc(_array, sizeof(DataType) * _capacity);
            if (nullptr == _array)
            {
                perror("realloc扩展空间失败!!!");
                return;
            }
        }
        _array[_size] = data;
        _size++;
    }
    // 其他方法...
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    DataType* _array;
    size_t _capacity;
    size_t _size;
};
void TestStack()
{
    Stack s;
    s.Push(1);
    s.Push(2);
}
int main() 
{
    TestStack();
    return 0;
}

private:
	Stack _pushst;
	Stack _popst;
};

    if (_array)
    {
        free(_array);
        _array = nullptr;
        _capacity = 0;
        _size = 0;
    }
}

    data = other.data;
}

    data = new int;
    *data = *(other.data);
}

private:
    int *data;
public:
    // 构造函数
    DeepCopy(int value) {
        data = new int;
        *data = value;
    }
    // 拷贝构造函数（深拷贝）
    DeepCopy(const DeepCopy& other) {
        data = new int;
        *data = *(other.data);
    }
    // 获取数据的函数
    int getData() const {
        return *data;
    }
    // 设置数据的函数
    void setData(int value) {
        *data = value;
    }
    // 析构函数
    ~DeepCopy() {
        delete data;
    }
};
int main() 
{
    DeepCopy obj1(10);
    DeepCopy obj2 = obj1;
    // 修改obj1的数据
    obj1.setData(20);
    std::cout 
private:
    int data;
public:
    // 拷贝构造函数
    MyClass(const MyClass other) 
    {
        // 构造信息
    }
};
int main() 
{
    MyClass obj;
    MyClass newObj = obj; // 这里会调用拷贝构造函数
    return 0;
}

    // 构造信息
}

	Stack st;
	return st;
}
// 2. 
Stack func()
{
	Stack st;
	return st;
}
// 3. 
Stack& func()
{
	static Stack st;
	return st;
}

	Stack st;
	return st;
}

	Stack st;
	return st;
}

	static Stack st;
	return st;
}