类的匿名对象管理模型

原创 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还是乱码

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

相关文章推荐

Kotlin 博客 companion object 伴生对象,getter,setter,内部,局部,匿名类,可变参数

先来看一个名为message的类 在这个类中有一段包含在companion object中的代码,需要说一下的是,Kotlin的class并不支持static变量,所以需要使用companion ...

《java入门第一季》之面向对象匿名内部类面试题

内部类面试题

黑马程序员—OC学习笔记—多个参数方法,匿名类,自定义对象初始化方法

———–Java培训、Android培训、IOS培训、.Net培训、期待与您交流!———— 本节内容,OC多个参数方法,匿名类,自定义对象初始化方法...

黑马程序员——分析匿名内部类使用外部定义的对象

在分析之前,首先说一下内部类定义在局部的特点。         内部类被定义在局部时:        1. 不可以被成员修饰符修饰;        2. 可以直接访问外部类中的成员,因为还持有外部类中...

黑马程序员——3.面向对象(堆栈、匿名、封装、构造函数、this、静态、数组工具类)

Java面向对象(堆栈、匿名、封装、构造函数、this、静态、数组工具类)

Objective-C 【类方法/对象方法-匿名类-new&alloc init区别】

——————————————————————————————————————————— 类方法   ①类方法:        + 开头的方法(定义的过程形式和对象方法一样,只不过 + 开头,这是唯...

黑马程序员_java的面向对象(对第八课多态..内部类..匿名内部类的总结)

------- android培训、java培训、期待与您交流! ---------- 通过今天对java语言面向对象的学习,我来给自己的学习内容做下简单直白的总结: 首先,我先来总结...

Java重修之路(十)面向对象之多态详解,Object类,内部类,匿名内部类详解

多态public class Hello { public static void main(String[] args) { Animal d = new Dog(); ...

JavaSE实战——面向对象(中) 抽象类,接口,多态,内部类,匿名内部类

抽象类     描述一个事物,却没有足够信息,这时就将这个事物称为抽象事物。面对抽象的事物,虽然不具体,但是可以简单化,不用面对具体的事物。(这样其实更方便于面对同一类对象)     抽象...

成员变量和局部变量的区别、方法的形参为类的情况及匿名对象、封装(private关键字)、this关键字、构造方法、static关键字

成员变量和局部变量 在介绍类的时候,已经说到了类的成员变量 成员变量是在类中而在方法之外 class ss{ int age; } 局部变量是在方法定义中或者方法声明中 class ss{ publi...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:类的匿名对象管理模型
举报原因:
原因补充:

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