定义一个class类：
class Test
{
public:
Test(int a, int b)
{
std::cout << this << " :Test::Test(int,int)" << std::endl;
ma = a;
mb = b;
}
Test(int a)
{
std::cout << this << " :Test::Test(int)" << std::endl;
ma = a;
mb = 0;
}
Test()
{
std::cout << this << " :Test::Test()" << std::endl;
ma = mb = 0;
}
Test(const Test& rhs)
{
std::cout << this << " :Test::Test(const Test&)" << std::endl;
ma = rhs.ma;
mb = rhs.mb;
}
Test& operator=(const Test& rhs)
{
std::cout << this << " :Test::operator=(const Test&)" << std::endl;
if (this != &rhs)
{
ma = rhs.ma;
mb = rhs.mb;
}
return *this;
}
~Test()
{
std::cout << this << " :Test::~Test()" << std::endl;
}
int getValue()
{
return ma;
}
private:
int ma;
int mb;
};
Test getObject1(Test& lhs)
{
return lhs.getValue(); //隐式调用
//return Test(lhs.getValue()); //显式调用
}
int main()
{
Test test1(10, 20);
Test rt;
rt = getObject(test1);
std::cout << "------------------" << std::endl;
Test test2 = 10;
test2 = 30;
std::cout << "------------------" << std::endl;
Test test3(20, 30);
(rt = test1) = test3;
std::cout << "------------------" << std::endl;
return 0;
}
问生成几个对象？
实参传形参过程中，形参对象会开辟内存，构造生成对象、用引用接收实参，减少内存的开辟，减少构造函数和析构函数的调用
012FFC9C :Test::Test(int,int) 调用两个参数的构造函数生成test1；
012FFC8C :Test::Test() 调用无参数的构造函数生成rt；（用户不定义系统默认生成）
012FFB80 :Test::Test(int) 调用一个参数的构造函数隐式生成临时对象；
012FFC8C :Test::operator=(const Test&) 调用赋值运算符的重载函数将隐式生成的临时对象赋值给rt
012FFB80 :Test::~Test() 隐式调用生成的临时对象在表达式结束，生存周期结束，被系统调用析构函数销毁
------------------
012FFC7C :Test::Test(int) 调用一个参数的构造函数生成test2
012FFB90 :Test::Test(int) int与Test类型不匹配，系统在类中寻找并调用一个参数的构造函数生成临时对象；
012FFC7C :Test::operator=(const Test&) 调用赋值运算符的重载函数将临时对象赋值给test2
012FFB90 :Test::~Test() 临时对象在表达式结束，生存周期结束，被系统调用析构函数销毁
------------------
012FFC6C :Test::Test(int,int) 调用两个参数的构造函数生成test3；
012FFC8C :Test::operator=(const Test&) (rt = test1) = test3 等价于 (rt.operator=(test1)) = test2
012FFC8C :Test::operator=(const Test&) 调用两次赋值运算符的重载函数先将test1赋值给rt再将test2赋值给rt
------------------
012FFC6C :Test::~Test() test3生存周期结束，被系统调用析构函数销毁
012FFC7C :Test::~Test() test2生存周期结束，被系统调用析构函数销毁
012FFC8C :Test::~Test() rt生存周期结束，被系统调用析构函数销毁
012FFC9C :Test::~Test() test1生存周期结束，被系统调用析构函数销毁
对象的生存周期：
class CGoods
{
public:
CGoods(char* name, float price, int amount)
{
std::cout << this << " :CGoods::CGoods(char*,float, int)" << std::endl;
mname = new char[strlen(name) + 1]();
strcpy(mname, name);
mprice = price;
mamount = amount;
}
CGoods(int amount)
{
std::cout << this << " :CGoods::CGoods(int)" << std::endl;
mname = new char[1]();
mamount = amount;
}
CGoods()
{
std::cout << this << " :CGoods::CGoods()" << std::endl;
mname = new char[1]();
}
~CGoods()
{
std::cout << this << " :CGoods::~CGoods()" << std::endl;
delete[] mname;
mname = NULL;
}
CGoods(const CGoods& rhs)
{
std::cout << this << " :CGoods::CGoods(const CGoods&)" << std::endl;
mname = new char[strlen(rhs.mname) + 1]();
strcpy(mname, rhs.mname);
mprice = rhs.mprice;
mamount = rhs.mamount;
}
CGoods& operator=(const CGoods& rhs)
{
std::cout << this << " :CGoods::operator=(const CGoods&)" << std::endl;
if (this != &rhs)
{
delete[] mname;
mname = new char[strlen(rhs.mname) + 1]();
strcpy(mname, rhs.mname);
mprice = rhs.mprice;
mamount = rhs.mamount;
}
return *this;
}
private:
char* mname;
float mprice;
int mamount;
};
CGoods ggood1("good1", 10.1, 20);
int main()
{
CGoods good3;
CGoods good4(good3);
good4 = good3;
static CGoods good5("good5", 10.1, 20);
CGoods good6 = 10;
CGoods good7(10);
CGoods good8 = CGoods("good8", 10.1, 20);
good6 = 20;
good7 = CGoods(20);
good8 = (CGoods)("good8",10.1, 20);
CGoods* pgood9 = new CGoods("good9", 10.1, 20);//heap
CGoods* pgood10 = new CGoods[2];
std::cout << "------------------" << std::endl;
CGoods* pgood11 = &CGoods("good11", 10.1, 20);
std::cout << "------------------" << std::endl;
//CGoods* pgood12 = 20;错误int 与 *不能进行’=‘操作
CGoods& rgood12 = CGoods("good11", 10.1, 20);
std::cout << "------------------" << std::endl;
const CGoods& rgood13 = 20;
delete pgood9;
delete[] pgood10;
return 0;
}
CGoods ggood2("good2", 10.1, 20);//.data
00AB0230 :CGoods::CGoods(char*,float, int) 调用三个参数的构造函数生成ggood1；
00AB0220 :CGoods::CGoods(char*,float, int) 调用三个参数的构造函数生成ggood2；
00A4F984 :CGoods::CGoods() 调用无参数的构造函数生成good3（或系统默认的构造函数）；
00A4F970 :CGoods::CGoods(const CGoods&) 调用拷贝构造函数生成用good3生成good4；
00A4F970 :CGoods::operator=(const CGoods&) 调用赋值运算符的重载函数将good3赋值给good4；
00AB023C :CGoods::CGoods(char*,float, int) 调用三个参数的构造函数生成静态的ggood5；放在.data段，
00A4F95C :CGoods::CGoods(int) 调用一个参数的构造函数生成ggood6
00A4F948 :CGoods::CGoods(int) 调用一个参数的构造函数生成ggood7
00A4F934 :CGoods::CGoods(char*,float, int) 调用三个参数的构造函数生成ggood8，直接生成对象，优化不产生临时对象
00A4F754 :CGoods::CGoods(int) int、Test类型不匹配，系统寻找并调用一个参数的构造函数生成临时对象；
00A4F95C :CGoods::operator=(const CGoods&) 调用赋值运算符的重载函数将临时对象赋值给test6
00A4F754 :CGoods::~CGoods() 临时对象在表达式结束，生存周期结束，被系统调用析构函数销毁
00A4F768 :CGoods::CGoods(int) 调用一个参数的构造函数显示生成临时对象
00A4F948 :CGoods::operator=(const CGoods&) 调用赋值运算符的重载函数将临时对象赋值给test7
00A4F768 :CGoods::~CGoods() 临时对象在表达式结束，生存周期结束，被系统调用析构函数销毁
00A4F77C :CGoods::CGoods(int) ’=‘（强转类型）（’，‘表达式）调用一个参数的构造函数显示生成临时对象
00A4F934 :CGoods::operator=(const CGoods&) 调用赋值运算符的重载函数将临时对象赋值给test8
00A4F77C :CGoods::~CGoods() 临时对象在表达式结束，生存周期结束，被系统调用析构函数销毁
001FD410 :CGoods::CGoods(char*,float, int) 用new在堆区调用三个参数的构造函数创建函数对象，在栈区用指针指向该对象的地址区域；遇到delete时堆区对象删除
001FD714 :CGoods::CGoods() 在堆区调用一个参数的构造函数生成CGoods对象，用*pgood10[0]指向
001FD720 :CGoods::CGoods() 在堆区调用一个参数的构造函数生成CGoods对象，用*pgood10[1]指向
------------------
00A4F7C0 :CGoods::CGoods(char*,float, int) 显式调用三个参数的构造函数生成临时对象并用* pgood11指向
00A4F7C0 :CGoods::~CGoods() 表达式结束，临时对象销毁
------------------
00A4F8F0 :CGoods::CGoods(char*,float, int) 显式调用三个参数的构造函数生成临时对象，用’&‘pgood12接受，’&‘提升临时对象的生存周期，将临时对象生存周期提升至main函数结束
------------------
00A4F8D0 :CGoods::CGoods(int) 调用一个参数的构造函数生成rgood13，’&‘提升临时对象的生存周期，
001FD410 :CGoods::~CGoods() delete pgood9 函数调用析构函数销毁
001FD720 :CGoods::~CGoods() delete[] pgood10
001FD714 :CGoods::~CGoods() delete[] pgood10
00A4F8D0 :CGoods::~CGoods() main函数结束，系统调用析构函数销毁rgood13
00A4F8F0 :CGoods::~CGoods() 系统调用析构函数销毁rgood12
00A4F934 :CGoods::~CGoods() 系统调用析构函数销毁rgood8
00A4F948 :CGoods::~CGoods() 系统调用析构函数销毁rgood7
00A4F95C :CGoods::~CGoods() 系统调用析构函数销毁rgood6
00A4F970 :CGoods::~CGoods() 系统调用析构函数销毁rgood4
00A4F984 :CGoods::~CGoods() 系统调用析构函数销毁rgood3
00AB023C :CGoods::~CGoods() 系统调用析构函数销毁rgood5
00AB0220 :CGoods::~CGoods() 系统调用析构函数销毁rgood2
00AB0230 :CGoods::~CGoods() 系统调用析构函数销毁rgood1
生存周期：
全局对象的生存周期：从程序运行开始，程序运行结束结束
静态局部对象的生存周期：调用点开始，函数结束结束
临时对象生存周期：调用点开始，表达式结束结束
临时量类型：
1.内置类型生成临时量为常量
2.自定义类型生成临时量为变量
3.隐式调用生成的临时量为常量
临时对象的优化：
临时对象的目的：为了生成新对象、以生成临时对象的方式生成新对象
引用能提升临时对象的生存周期、把临时对象提升和引用变量相同的生存周期
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
