类的匿名对象管理模型

原创 2015年07月08日 16:53:53

背景知识1:

class ABCD
{
public:
                 ABCD(int a, int b, int c)
                {
                                 this->a = a;
                                 this->b = b;
                                 this->c = c;
                                 printf("ABCD() construct, a:%d,b:%d,c:%d  \n" , this-> a, this ->b, this-> c);
                }
                ~ ABCD()
                {
                                 printf("~ABCD() construct,a:%d,b:%d,c:%d  \n" , this-> a, this ->b, this-> c);
                }
                 int getA ()
                {
                                 return this ->a;
                }
protected:
private:
                 int a ;
                 int b ;
                 int c ;
};

int run3 ()
{
                 printf("run3 start..\n" );
                 ABCD(400, 500, 600); //ABCD是类名,没有声明对象,直接调用此时则生成匿名对象
                 printf("run3 end\n" );
                 return 0;
}

int main ()
{
                 run3();
                 system("pause" );
                 return 0;
}

这里写图片描述
ABCD是类名,没有声明对象,直接调用此时则生成匿名对象

但是为什么先析构,后面才出现run3 end?
这就说明了,函数还没有结束,就先析构了,换句话说,匿名对象,在执行完他的功能后立即就会被回收(并不像其他临时变量,要在函数执行完回收)

背景知识2:

上述run3()替换为:

int run3 ()
{
                 printf("run3 start..\n" );
                 ABCD abcd = ABCD(100, 200, 300);
                 printf("run3 end\n" );
                 return 0;
}

这里写图片描述
则结果变成:

这说明匿名对象直接转为,对象abcd,然后在函数结束之后析构

转化验证:

class Test03
{
public :
                 Test03 ()
                {
                                 cout << "ooo我在无参构造 this= " << this<< endl ;

                }
                 Test03 (const Test03 & C )
                {
                                 cout << "ooo我在进行拷贝构造 this= " << this << endl ;
                }
                 Test03 (int _a, int _b)
                {
                                 cout << "ooo我在有参构造 this= " << this << endl ;
                }
                ~ Test03 ()
                {
                                 cout << "ooo我在析构 this= " << this << endl ;
                }
                 void OutThis ()
                {
                                 cout << " 我的this= " << this << endl ;
                }
};
Test03 g ()
{
                 Test03 A (1, 2);
                 return A ;
}
void shiyan ()
{
                 cout << "实验开始" << endl;
                 Test03 B = g();  //g()生成的匿名对象直接转化为B,来提高效率
                 B .OutThis ();

                 Test03 C ;
                 C = g ();
                 C .OutThis ();

                 cout << "实验结束" << endl;
}
void main ()
{
                 shiyan ();
                 system ("pause" );
}

这里写图片描述

匿名对象强化:

class MyTest
{
public:
                 MyTest(int a, int b, int c)
                {
                                 this->a = a;
                                 this->b = b;
                                 this->c = c;
                                 printf("MyTest:%d, %d, %d\n" , a, b, c);
                }

                 MyTest(int a, int b)
                {
                                 this->a = a;
                                 this->b = b;
                                 MyTest(a , b, 100); //注
                                 printf("MyTest:%d, %d\n" , a, b);
                }
                ~ MyTest()
                {
                                 printf("~MyTest:%d, %d, %d\n" , a, b, c);
                }

protected:
private:
                 int a ;
                 int b ;
                 int c ;

public:
                 int getC () const { return c ; }
};

int main ()
{
                 MyTest t1 (1, 2);
                 printf("c:%d" , t1.getC()); //请问c的值是?
                 system("pause" );
                 return 0;
}

这里写图片描述
这里标“注”的地方是重点
在执行 MyTest(a , b, 100); 时 其实只是生成了匿名对象,会重新分配一块内存,所以这里支队新生成的匿名对象中的c进行操作,并且会在使用完匿名对象后立即析构。所以是

所以会在 printf(“MyTest:%d, %d\n” , a, b);这句执行前就析构了,而且本类中的c并没有被赋值,所以c还是乱码

版权声明:本文为博主原创文章,未经博主允许不得转载。

反射 EF SqlQuery 返回匿名类型

//var x = DynamicSqlQuery.DynamicSqlQueryMethod(db.Database, sql, null).ToListAsync(); ...
  • hejisan
  • hejisan
  • 2016年09月21日 15:08
  • 2946

JSON序列化与反序列化匿名类型

一、序列化匿名类型 1.序列化一个var类型 using System; using System.Collections.Generic; using System.Linq; using Syst...
  • lovegonghui
  • lovegonghui
  • 2015年12月10日 16:46
  • 3861

匿名对象与非匿名对象的区别

类封装完以后就可以通过使用new关键字和类的构造方法来创建对象,这种对象分为两种:匿名对象与非匿名对象。何为匿名对象,何为非匿名对象呢?举个例子:假如有如下类:     package com.hei...
  • wangshuxuncom
  • wangshuxuncom
  • 2013年11月06日 07:42
  • 7136

java基础总结 -- 泛型 在类、接口、方法、匿名类、元组等使用 堆栈例子 商店模型

为什么使用泛型:     在面向对象编程语言中,多态算是一种泛化机制。例如,你可以将方法的参数类型设为基类,那么 该方法就可以接受从这个基类中导出的任何类作为参数,这样的方法更通用一些,可应用的地方也...
  • zghwaicsdn
  • zghwaicsdn
  • 2016年02月15日 10:44
  • 501

JSON 服务器端返回多个JSON对象。(匿名类)

服务器返回一个参数: 浏览器端(XXX.html  XXX.aspx): $.post("XXX.ashx", { "第一个参数": 123,"第二个参数":456 }, function (...
  • houyanhua1
  • houyanhua1
  • 2017年12月29日 19:58
  • 123

final、static、匿名对象、内部类、包的声明与访问、四种访问修饰符、代码块

final:关键字,最终的意思 final修饰的类:最终的类,不能被继承 final修饰的变量:相当于是一个常量, 在编译生产.class文件后,该变量变为常量值 final修饰的方法:最终的方...
  • thybxgfhg
  • thybxgfhg
  • 2018年01月10日 20:48
  • 9

匿名内部类引用外部对象要加final修饰符的原因

为什么在匿名内部类中引用外部对象要加final修饰符呢,因为,在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期,以线程为例,当外部的变量生命周期已经完结之后,内部的线程还在运行...
  • lb_383691051
  • lb_383691051
  • 2015年08月16日 10:58
  • 1134

Java之final、static、匿名对象和内部类

第1章  final关键字 1.1      final的概念 继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让...
  • xiaoyuxianshenging
  • xiaoyuxianshenging
  • 2017年06月19日 16:36
  • 216

面向对象(关键字,内部匿名类,)day10

10.01_面向对象(package关键字的概述及作用)(了解) A:为什么要有包 将字节码(.class)进行分类存放 包其实就是文件夹 B:包的概述 举例: 学生:增加,删除,修改,...
  • qq_16103331
  • qq_16103331
  • 2016年07月13日 11:48
  • 206

java面向对象的三个特征以及匿名内部类

封装、继承、多态 封装和继承几乎都是为多态而准备的 一、      封装 首先,属性能够描述事物的特征,方法能够描述事物的动作。封装就是把同一类事物的共性(包括属性和方法)归到同一类中,方便使用...
  • qq_26122557
  • qq_26122557
  • 2017年08月08日 17:54
  • 71
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:类的匿名对象管理模型
举报原因:
原因补充:

(最多只允许输入30个字)