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;*/
        }
        
内容来源于网络如有侵权请私信删除