对象初始化：构造函数和复制构造函数
在设计一个类时，往往要设计构造函数。一般对象的初始化使用构造函数初始化，如果没有构造函数则会使用默认构造函数。还可以用复制构造函数来通过一个已有对象初始化一个新的对象。设计一个类来表现对象的初始化，复制构造，以及赋值。
在Stack.hpp头文件中声明类的成员。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | //Stack.hpp
#pragma once
classStack {
public:
Stack(intmax_size);
~Stack();
//复制构造函数
Stack(constStack& s);
boolIsEmpty()const;
boolIsFull()const;
voidPush(intdata);
voidPop();
intTop()const;
private:
int* buffer_;
int* top_;
intcapacity_;
};
|
在Stack.cpp中实现类中的方法。包括有一个表示大小的参数的构造函数，析构函数，拷贝构造函数，栈空，栈满的判断函数，以及Push、Pop、Top等方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | //Stack.cpp
#include "Stack.hpp"
#include <iostream>
Stack::Stack(intmax_size) :
capacity_(max_size),
//buffer_(new int[max_size]),
buffer_(static_cast<int*>(std::malloc(sizeof(int) * max_size))),
top_(buffer_) {}
Stack::~Stack() {
std::free(buffer_);
}
Stack::Stack(constStack& s) :
capacity_(s.capacity_),
buffer_(static_cast<int*>(std::malloc(sizeof(int) * s.capacity_))),
top_(buffer_ - s.buffer_ + s.top_) {
std::memcpy(buffer_, s.buffer_,sizeof(int) * s.capacity_);
}
boolStack::IsEmpty()const{
returntop_ <= buffer_;
}
boolStack::IsFull()const{
returntop_ >= buffer_ + capacity_;
}
voidStack::Push(intdata) {
if(this->IsFull())
throw"Stack is full!";
*top_++ = data;
}
voidStack::Pop() {
if(this->IsEmpty())
throw"Stack is Empty!";
top_--;
}
intStack::Top()const{
if(this->IsEmpty())
throw"Stack is Empty!";
return*(top_ - 1);
}
|
在主函数前引用Stack.hpp头文件。创建一个s1对象并push两个值，在使用拷贝构造复制s1创建对象s2。确认s1和s2的栈顶相等。在s2中push一个新的值，s1和s2的栈顶变得不相等。
创建新的对象s3，再使用类默认的赋值运算符重载给s3赋值为s1。这样的赋值会把栈中的指针属性的地址直接复制到新的对象。在给 s3 push 了新的值之后，s1、s3的 top_ 属性变得不相等，但是s1、s3的buffer却指向同一区域，在程序结束调用析构时会重复释放同一块内存造成报错。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | //OverloadAssignment
#include <iostream>
#include "Stack.hpp"
intmain() {
Stack s1(16);
s1.Push(1);
s1.Push(2);
Stack s2 = s1;//调用复制构造函数
std::cout <<"s1 top: "<< s1.Top() << std::endl;
std::cout <<"s2 top: "<< s2.Top() << std::endl;
s2.Push(3);
std::cout <<"s2 pushed 3"<< std::endl;
std::cout <<"s1 top: "<< s1.Top() << std::endl;
std::cout <<"s2 top: "<< s2.Top() << std::endl;
Stack s3(16);
s3 = s1;//调用赋值运算符重载
std::cout <<"s3 top: "<< s3.Top() << std::endl;
//观察报错信息，s3的析构函数被调用了两次，说明s3和s1指向了同一块内存区域，导致内存被重复释放了。
}
|
虽然能够正常输出所有结果，但是在程序结束后析构对象时由于重复释放相同空间引发报错。
1 2 3 4 5 6 7 8 9 10 | s1 top: 2
s2 top: 2
s2 pushed 3
s1 top: 2
s2 top: 3
s1 top: 2
s3 top: 2
s3 pushed 3
s1 top: 2
s3 top: 3
|
针对报错，copilot的分析：
简短结论（错误） 程序在 std::free(buffer_) 处触发断点/崩溃。根本原因是对象复制后发生了浅拷贝——s3 = s1; 使用了编译器生成的默认赋值运算符（类声明只有拷贝构造函数，未定义 operator=），导致 s1 和 s3 共享同一 buffer_ 指针，程序结束时两次释放同一内存（double free/堆破坏），因此 free 抛出异常/断点。
为什么会发生（<200字） Stack 定义了自定义拷贝构造函数（会分配新缓冲区），但没有自定义拷贝赋值运算符，编译器生成的默认 operator= 做逐成员赋值，把 buffer_ 指针从 s1 拷贝到 s3（浅拷贝）。当两个对象析构时会重复释放同一块内存或在赋值后原对象的缓冲区被提前释放或覆盖，导致堆损坏，free 崩溃。
重载赋值运算符
如果需要对自定义对象赋值，就需要重载赋值运算符。
在Stack.hpp中声明重载赋值运算符的函数。并在Stack.cpp中完成。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | //重载赋值运算符
//函数的返回值是一个引用，指向当前对象。在s3 = s2 = s1;这样的链式赋值中，s2 = s1的结果是s2的引用，然后s3 = s2实际上是s3 = (s2 = s1)，因此s3最终也会得到s1的值。
Stack& Stack::operator =(constStack& s) {
//给自己赋值
if(this== &s)
return*this;
//释放原有资源
std::free(buffer_);
capacity_ = s.capacity_;
buffer_ =static_cast<int*>(std::malloc(sizeof(int) * s.capacity_));
top_ = buffer_ - s.buffer_ + s.top_;
std::memcpy(buffer_, s.buffer_,sizeof(int) * s.capacity_);
return*this;
}
|
赋值函数的返回值是一个引用，指向当前对象。在s3 = s2 = s1;这样的链式赋值中，s2 = s1的结果是s2的引用，然后s3 = s2实际上是s3 = (s2 = s1)，因此s3最终也会得到s1的值。
再去运行之前的主函数，就不会发生重复释放内存的报错了。
这样的赋值函数参数是自己的类型，如果不手动实现会隐含一个默认的方法。这样的赋值函数叫做拷贝赋值函数。与拷贝构造函数相似，都是传递一个自身的const引用类型。
除了拷贝赋值函数也存在一般的赋值函数，以一个复数类为例：
1 2 3 4 5 6 7 8 9 10 11 | classComplex {
public:
Complex(doubler,doublei) : real_(r), imag_(i) {};
Complex& operator =(doubler) {
real_ = r;
imag_ = 0.0;
return*this;
}
private:
doublereal_, imag_;
};
|
隐式构造
除此之外，如果类中没有声明赋值函数，但是存在有一个参数的构造函数，也可以用隐式构造的方法使用等号给对象赋值。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | classComplex {
public:
Complex(doubler) : real_(r), imag_(0.0) {};
Complex(doubler,doublei) : real_(r), imag_(i) {};
public:
doublereal_, imag_;
};
intmain() {
Complex c1(1, 2);
//使用了隐式构造函数
Complex c2 = 45.0;
//使用了隐式构造函数
c1 = 4;
std::cout << c1.real_ <<" + "<< c1.imag_ <<"i"<< std::endl;
std::cout << c2.real_ <<" + "<< c2.imag_ <<"i"<< std::endl;
return0;
}
|
如果不希望使用隐式构造，可以在构造函数前加explicit关键字，explicit翻译是明确的、不加掩饰的，计算机中是显式的意思，加上explicit的构造函数无法被隐式调用。
比如在Stack类中构造函数可以被隐式调用，但是这种用法意义不明确，如果不希望实现这种用法可以在构造函数前加上explicit。
1 2 3 4 5 6 7 8 | classStack {
public:
explicitStack(intmax_size);
//……
intmain (){
Stack st(16);
st = 20;//会报错
}
|
比如在复数类中同时定义了另一个构造函数，此时使用隐式构造会产生歧义导致程序无法运行，可以把这个有两个参数且有初值的构造函数指定为explicit。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | classComplex {
public:
Complex(doubler) : real_(r), imag_(0.0) {};
explicitComplex(doubler = 0,doublei = 0) : real_(r), imag_(i) {};
public:
doublereal_, imag_;
};
intmain() {
Complex c1(1, 2);
//使用了隐式构造函数
Complex c2 = 45.0;
//使用了隐式构造函数
c1 = 4;
std::cout << c1.real_ <<" + "<< c1.imag_ <<"i"<< std::endl;
std::cout << c2.real_ <<" + "<< c2.imag_ <<"i"<< std::endl;
return0;
}
|
这样可能没什么意义，因为给了初值的构造函数可以用单个参数隐式构造也可以用多个参数隐式构造。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | classComplex {
public:
Complex(doubler = 0,doublei = 0) : real_(r), imag_(i) {};
public:
doublereal_, imag_;
};
intmain() {
Complex c1(1, 2);
//使用了隐式构造函数
Complex c2 = 45.0;
//使用了隐式构造函数
c1 = 4;
std::cout << c1.real_ <<" + "<< c1.imag_ <<"i"<< std::endl;
std::cout << c2.real_ <<" + "<< c2.imag_ <<"i"<< std::endl;
//使用多个参数的隐式构造
c1 = { 45, 56 };
std::cout << c1.real_ <<" + "<< c1.imag_ <<"i"<< std::endl;
return0;
}
|
到此这篇关于c++面向对象：对象的赋值的文章就介绍到这了