学习第56天

C++

1. 临时对象、

   1. 即临时变量、由系统和写代码时产生、可以通过优化代码来减少部分写代码时产生的临时变量、
   2. 栈常存放临时变量、栈上的临时变量一般是由系统自动产生的、
   3. 使用new产生的空间必须通过使用delete来释放、

2. 产生临时对象

   1. 以传值的方式给函数传递参数、

      1. class a
         {
         public:
         	int b1;
         	int b2;
         public:
         	a(int f1 = 0, int f2 = 0);//声明时需要由默认值
         	a(const a& c) :b1(c.b1), b2(c.b2)//拷贝构造函数、
         	{
         		cout << "拷贝" << endl;
         	}
         	virtual ~a()//析构函数
         	{
         		cout << "调用了析构函数"<< endl;
         	}
         public:
         	int e(a d);//普通函数
         	//int e(a &d);//引用便产生影响
         };
         a::a(int f1, int f2 ):b1 (f1),b2(f2)//类外实现构造函数、声明时需要由默认值、定义时可以不需要默认值
         {
         	cout<<"调用构造函数"<<endl;
         	cout << "b1是" <<b1<< endl;
         	cout << "b2是" << b2 << endl;
         }
         int a::e(a d)//局部对象、临时对象（特殊的、一般临时对象是不显示代码的、这是假的临时对象？）、临时使用求和、
         //int a::e(a &d)//引用便产生影响   30行  左值引用、 直接传值、
         {
         	int q = d.b1 + d.b2;
         	d.b1 = 100;//赋新值、修改值对外没有影响因为是拷贝出来的、引用有影响、
         	return q;
         }
         int main()
         {
         	a g(10, 30);//调用构造函数、
         	int he = g.e(g);//会导致拷贝构造函数执行、
         	cout << "合是" << he << endl;
         	cout << "b1的值" << g.b1 << endl;
         

   2. 类型转换生成的临时对象和隐式类型转换以保证函数调用成功、

      1. C++语言只会为const引用（const string &n）产生临时变量、而不会为非const引用产生临时引用、

      2. #include <iostream>
         #include<stdio.h>
         #include<string>
         #include<string.h>
         #include <vector>
         using namespace std;
         class a
         {
         public:
         	int b1;
         	int b2;
         public:	
         	a(int f1 = 0, int f2 = 0);//声明时需要由默认值
         	a(const a& c) :b1(c.b1), b2(c.b2)//拷贝构造函数、
         	{
         		cout << "拷贝" << endl;
         	}
         	a& operator=(const a&j)//拷贝赋值运算符
         	{
         		b1 = j.b1;
         		b2 = j.b2;
         		cout << "调用了拷贝赋值运算符" << endl;
         		return *this;
         	}
         	virtual ~a()//析构函数
         	{
         		cout << "调用了析构函数"<< endl;
         	}
         public:
         	int e(a d);//普通函数
         	//int e(a &d);//引用便产生影响
         };
         a::a(int f1, int f2 ):b1 (f1),b2(f2)//类外实现构造函数、声明时需要由默认值、定义时可以不需要默认值
         {
         	cout<<"调用构造函数"<<endl;
         	cout << "b1是" <<b1<< endl;
         	cout << "b2是" << b2 << endl;
         
         }
         int a::e(a d)//局部对象、临时对象（特殊的、一般临时对象是不显示代码的、这是假的？）、临时使用求和、
         //int a::e(a &d)//引用便产生影响   43行  左值引用、 直接传值、
         {
         	int q = d.b1 + d.b2;
         	d.b1 = 100;//赋新值、修改值对外没有影响因为是拷贝出来的、引用有影响、
         	return q;
         }
         //统计字符h在n中出现的次数、将次数返回、
         int k(const string &n, char h)//定义了string类型、n的形参绑定到啦string临时对象上、
         {
         	const char* m = n.c_str();
         	int v = 0;
         	return v;//执行到此步骤则string临时对象会被销毁
         }
         int main()
         {
         	//a g;
         	//g = 100;/*产生了临时对象、将100给了a、
         	//用100来创建了一个类型为a的临时对象、
         	//调用拷贝赋值运算符吧临时对象里面的内容赋值给g对象
         	//销毁创建的临时对象a*/
         	a g = 200;/*优化56行代码、使其调用一次函数、没有临时对象的生成、g = 200不再是赋值运算符而是定义是初始化、定义时便预留了空间、在g的预留空间中构造200、*/
         	char r[100] = "qwertyuiopqwertwww";
         	int t = k(r, 'w');//类型不匹配、char和string类型不匹配、编译器默认构造string类型的临时对象、
         	/*cout << "合是" << he << endl;
         	cout << "b1的值" << g.b1 << endl;*/
         }