精华内容
下载资源
问答
  • C++对象实例化及调用

    万次阅读 2017-08-01 11:15:43
    class TV { public: int type; void changeVol() { cout ; } };从栈中实例化对象调用TV tv; Tv.type = 0; Tv.changeVol();从堆中实例化对象调用TV *p = new TV(); if(NULL == p) {
    class TV
    {
    public:
        int type;
        void changeVol()
        {
            cout << "vol changed" <<endl;
        }
    };

    从栈中实例化对象调用

    TV tv;
    Tv.type  =  0;
    Tv.changeVol();

    从堆中实例化对象调用

    TV *p = new TV();
    if(NULL == p)
    {
        return 0;
    }
    p->type  =  0;
    p->changeVol();
    delete p;
    p = NULL;
    展开全文
  • C++ 对象实例化方法

    千次阅读 2011-07-22 17:40:50
    问:c++里面, 创建对象, ClassName object(初始参数);在Stack栈里面分配空间,自动释放。或者用


    问:

    c++里面, 创建对象,                                                                             ClassName object(初始化参数)在Stack栈里面分配空间,自动释放

    或者用                                                                            ClassName *object=new ClassNam();在heap堆里面分配空间,要手动释放

     

    什么时候用哪一种来创建对象比较好呢?  

    小弟初学C++。以前学过java,从来都是new。所以对这个问题不很清楚。



    答:

    ClassName object(初始化参数);在Stack栈里面分配空间,自动释放。  

    不一定在栈中,比如全局变量

    说一点
    就类来讲,动态分配比较灵活,并且更能够体现多态特性


    引用 6 楼 artman 的回复:
    什么时候用哪一种来创建对象比较好呢?

    new以下情况可以使用
    1 申请对象数量不确定时
    2 需要空间较大时

    自己管理内存可以可以节省空间。


    参考网页:http://topic.csdn.net/u/20080707/15/d6e1262a-7ba6-4b1b-b99b-7b9b6685bdf7.html

    展开全文
  • C++实例化出的对象的生存周期

    千次阅读 2017-11-16 22:46:33
    c++实例化出的对象的生存周期。

    我们知道在C++中系统默认提供了六个函数,为了更好的理解实例化出的对象的生存周期,我们结合默认的的四个函数(构造函数、拷贝构造函数、赋值运算符重载函数、析构函数)来举例说明实例化出的对象的生存周期。

    首先先定义一个类CObject;如下:

    #include<iostream>
    using namespace std;
    #pragma waring(disablie:4996)
    class CObject
    {
    public:
    	CObject()
    	{
    		mname=new char[1];
    		cout<<this<<":"<<mname<<"CObject()"<<endl;
    	}
    	CObject(char *name,int num)
    	{
    		mname=new char[strlen(name)+1];
    		strcpy(mname,name);
    		mnum=num;
    		cout<<this<<":"<<mname<<"CObject(char *,int)"<<endl;
    	}
    	CObject(int num)
    	{
    		mname=new char[1];
    		mnum=num;
    		cout<<this<<":"<<mname<<"CObject(int)"<<endl;
    	}
    	CObject(const CObject &rhs)
    	{
    		mname=new char[strlen(rhs.mname)+1];
    		strcpy(mname,rhs.mname);
    		mnum=rhs.mnum;
    		cout<<this<<":"<<mname<<"CObject(const)"<<endl;
    	}
    	void operator=(const CObject &rhs)
    	{
    		if(this==&rhs)
    		{
    			return ;
    		}
    		delete[] mname;
    		mname=new char[strlen(rhs.mname)+1];
    		strcpy(mname,rhs.mname);
    		mnum=rhs.mnum;
    		cout<<this<<":"<<mname<<"operator()"<<endl;
    	}
    	~CObject()
    	{
    		cout<<this<<":"<<mname<<"~~CObject()"<<endl;
    		delete[] mname;
    		mname=NULL;
    	}
    private:
    	char *mname;
    	int mnum;
    };
    我们自己提供了不带参数的构造函数、带有一个参数的构造函数、带有两个的构造函数、拷贝构造函数、赋值运算符重载函数。

    下面我们在main函数中实例化对象来进行分析每一种情况下对象对这几个函数的调用。

    例1、

    //测试普通的对象的生存周期
    
    /*static CObject object1("object1",1);
    int main()
    {
    	CObject object3;
    	CObject object4("object4",4);
    	CObject *pobject=new CObject("pobject",1);
    	delete pobject;
    	CObject object5;
    	cout<<"--------------------"<<endl;
    	return 0;
    }
    static CObject object2("object2",2);
    运行之后:

    构造对象的顺序:object1->object2->object3->object4->在堆上构造一个对象,且用指针pobject指向它->object5

    析构对象的顺序:object5->object4->object3->object2->object1

    总结:

    (1)先构造全局对象,在构造main函数中的对象;

    (2)先构造的后析构,后构造的先析构;

    (3)在堆上构造的对象,只有遇到delete之后才被析构;

    (4)直接实例化出的对象的生存周期都是从调用点生成,return 0;之后最后一个 } 之前结束。

    例2:

    int main()
    {
            CObject *pobject=new CObject("pobject",1);
    	//在堆上开辟了一个对象,指针pobject指向它;不见delete就不销毁。
    	CObject object("object",1);
    	//调用带两个参数的构造函数,生成一个对象;
    	CObject("vobject",1);
    	//调用带两个参数的构造函数,显示生成一个临时对象;
    	delete pobject;
    
            cout<<"--------------------"<<endl;
    	return 0;
    
    }
    运行之后:

    总结:

    (1)这一个例子证明了在堆上构造的对象只有遇到delete才被析构。(第一行和最后一行)

    (2)构造临时对象属于一个表达式,表达式在遇到;或者?之后就运行结束,所以从运行结果看出临时对象CObject("vobject",1)刚开始构造在;之前就被析构。

    例3:

    int main()
    {
            CObject object1;
            //调用不带参数的默认构造函数,生成对象object1
            //析构3
            CObject object2("object2",2);
            //调用带两个参数的构造函数,生成一个对象object2;
            //析构2
            object1=CObject("vobject1",1);
            //调用带两个参数的构造函数,显示生成一个临时对象;
            //调用赋值运算符重载函数生成对象object1;
            //再调用析构函数析构临时对象
    
            cout<<"--------------------"<<endl;
            return 0;
    }
    运行结果:


    总结:在这里也构造了一个临时对象,但该临时对象的生成是为了给已存在的对象进行赋值,所以临时对象先生成,再调用赋值运算符重载函数进行赋值,使命完成之后,在本表达式结束之前就被析构。

    例4:

    int main()
    {
            CObject object3;
    	//调用不带参数的默认构造函数,生成对象object1
    	//析构3
    	CObject object4("object4",4);
    	//调用带两个参数的构造函数,生成一个对象object4;
    	//析构2
    	CObject object5=CObject("vobject",1);
    	//用构造临时对象的方法构造object5;
    	//析构1
           cout<<"-------------------------------"<<endl;

        return 0;

    }

    运行结果:


    总结:

    (1)在定义时进行赋值称为初始化;在定义后进行赋值称为赋值。

    (2)拷贝构造函数也是构造函数。因此在本例子中没有临时对象的生成,而是用构造临时对象的方式构造了对象object5。

    (3)是否有临时量产生需要明确产生临时量的目的,如果是为了给已存在的对象赋值,则有临时对象产生;如果为了初始化一个对象,则编译器进行优化,临时对象不产生。

    例5:

    int main()
    {
            CObject object6;
            //调用不带参数的默认构造函数,生成对象object1

        //析构3

    object6=(CObject)("object6",6);

    //调用带一个参数的构造函数,生成一个临时对象//在逗号结束前析构临时对象6//调用赋值运算符重载函数生成一个对象object6//析构2

    cout<<"-----------------------------"<<endl; return 0; }

    运行结果:


    总结:本例中object6=(CObject)("object6",6)这是一个逗号能表达式,所以逗号表达式的结果就是6;最后通过表达式的结果调用带有一个参数的构造函数来构造一个临时对象。

    例6:

    int main()
    {
            CObject object7=CObject("object7",7);
    	object7=2;
    	//调用拷贝构造函数生成对象object7
    	//析构3
    	//调用带有一个参数的构造函数隐式生成一个临时对象
    	//在逗号前析构临时对象1
    	//调用赋值运算符重载函数给对象object7赋值
    	//析构2
            cout<<"----------------------------------------"<<endl;
            return 0;
    }

    运行结果:


    总结:这里需要注意一下隐式生成的临时对象。

    例7:

    int main()
    {
            CObject *pobject1=&CObject("pobject1",1);
    	CObject &pobject2=CObject("poject2",2);
    	//调用带两个参数的构造函数生成一个临时对象,用pobject1指向它,在表达式结束之前析构
    	//在逗号之前析构临时对象
    	//生成一个对象pobject2
    	//在return 之后析构
            cout<<"----------------------------"<<endl;
            return 0;
    }
    

    运行结果:


    总结:

    (1)如果是指针指向的对象,则临时对象生成,在表达式结束之前析构。

    (2)如果是通过引用引用一个对象,则临时对象的生存周期被提升为该引用的对象,在main函数结束时析构。

    例8:

    void fun1(CObject object90)
    {}
    int main()
    {
            CObject object8;
    	fun1(object8);
           //调用默认构造函数生成对象object8

        //实参初始化形参,调用拷贝构造函数形成形参

        //在;结束后析构形参

        //在return之后析构object8

     cout<<"-------------------"<<endl; return 0; }

    运行结果:


    总结:

    (1)实参传形参是初始化的过程。

    (2)构造的形参在调用函数结束时析构。

    例9:

    void fun2(CObject &rhs)
    {}
    int main()
    {
    	fun2(CObject("objectp",1));
    	//因为传的是引用,所以为了形参的初始化,临时量存在(调用的是带有两个参数的构造函数)
    	//在;之前析构临时量
    	cout<<"----------------------"<<endl;
    	return 0;
    }

    运行结果:

    总结:调用函数传引用时,尽管是初始化,但是临时量会产生,该临时对象生存周期提升为形参的生存周期。

    例10:

    void fun2(CObject &rhs)
    {}
    int main()
    {
    	CObject object9;
    	fun2(object9);
    	//传引用不需要有对象的生成,只有object9生成,在return之后析构
    	cout<<"---------------"<<endl;
    	return 0;
    }

    运行结果:

    总结:在传引用时不生成对象。

    例11:

    void fun3(CObject *rhs)
    {}
    int main()
    {
    	CObject object;
    	fun3(&object);
    	//生成一个对象
    	fun3(&CObject("object",1));
    	//生成一个临时对象,在;之前析构
    	cout<<"--------------------"<<endl;
    	return 0;
    }
    运行结果:

    总结:调用函数传指针时,如果有临时量生成,则临时量的生存周期在表达式解释时析构。


    由上面所有的例子简单总结一下:

    (1)一般对象的生存周期都是从调用点开始,到main函数结束时析构。

    (2)如果有临时对象的产生,当不做引用时一定是在表达式结束时析构,做引用时生存周期与一般对象一样。

    (3)调用函数时,传引用不生成对象。

    (4)调用构造函数一般是初始化一个对象或者实参传形参时。


     

    
    
    
    
    展开全文
  • c++ 字符串实例化对象,通过map绑定字符和对象
  • 实例化对象写法的区别 栈中实例化对象: 堆中实例化对象: 最大区别就在于,从栈中申请内存,在使用完后无需释放,但是从堆中申请内存,使用完以后必须释放! 注意:从堆中申请内存,是有可能失败的,所以...

    一. 实例化对象写法的区别

    栈中实例化对象:

    堆中实例化对象:

    最大区别就在于,从栈中申请内存,在使用完后无需释放,但是从堆中申请内存,使用完以后必须释放!

    注意:从堆中申请内存,是有可能失败的,所以要加上对于申请内存是否成功的判断!

    二. 访问对象成员的区别

    展开全文
  • C++实例化方式

    千次阅读 2018-10-16 16:26:22
    C++中,实例化方式一般有两种: 1,直接定义对象,这时成员变量需要通过 ‘.' 来访问,如 A a; 2,定义一个类指针,这时需要用到new方法,如 A *a = new A。访问类的成员函数或者说是成员变量需要通过 ‘-&gt;...
  • C++实例化对象数组

    万次阅读 2017-08-02 10:46:52
    从栈中实例化Coordinate coor[3]; Coor[0].m_iX = 3; coor[0].m_iY = 5;从堆中实例化Coordinate *p = new Coordinate[3]; p->m_iX = 11; p[0].m_iY = 13; p++; p->m_iY = 9;p = coor[0]; delete []p; p = NULL;
  • C++只能实例化一个对象的类

    千次阅读 2015-10-18 18:07:54
    # include # include using namespace ...//功能:只能通过此函数调用构造函数进行初始化,然后返回唯一对象地址 ...主函数创建的“两个对象”存储地址是完全一致的,所以实质只实例化了一个对象
  • C++类的实例化对象

    千次阅读 2018-09-02 18:47:11
    C语言使用函数对内容进行封装的,而C++是用类进行封装的 ...类在创建实例化对象时,类本身并不被分配空间 类对象包括类里的成员变量 若计算类的大小,只需计算成员变量大小之和,但要注意内存对齐 空类大小为一个...
  • 收集几个 MFC串行数据和C++对象实例 收集几个 MFC串行数据和C++对象实例
  • C++中堆栈对象实例化笔记

    千次阅读 2017-07-06 14:32:57
    //建立一个stu对象,此种方式所建立的实例化对象是在栈中进行实例化对象,在程序使用完毕之后系统将会自动进行垃圾的回收操作 Student *student=new Studnet();//通过关键字new来获取的实例化对象是在堆当中开辟...
  • C++模板实例化与调用

    万次阅读 2015-10-29 13:13:41
    模板的实例化指函数模板(类模板)生成模板函数(模板类)的过程。对于函数模板而言,模板实例化之后,会生成一个真正的函数。而类模板经过实例化之后,只是完成了类的定义,模板类的成员函数需要到调用时才会被初始...
  • new创建的对象需要指针接收,一出初始,多出使用 new出来的对象需要delete销毁,不用new的对象只能在它的作用域使用,作用域结束对象自动调用类的析构函数 new出来的对象在堆空间,不用new的在栈空间 转至 ...
  •  我们假设,学生是对象对象的属性有ID和Score,那么如果班级里面有100个学生,那么每个对象都要用类进行实例化的话,那真是太恐怖了,此时,C++对象数组该上场了,一个数组直接搞定是不是很方便呢?...
  • C++的三种实例化对象方式

    千次阅读 2019-10-10 09:00:51
    C++的三种实例化对象方式 2019-05-04 19:15:43d89538239阅读数 385 一、隐式创建 class CEmployee { private: int age; int id; public: CEmployee() { cout << "这是构造函数" << endl; } ...
  • C++类的实例化对象的大小之sizeof()

    千次阅读 2014-10-19 20:02:49
    C++类的实例化对象的大小之sizeof()
  • C++只在栈或堆上实例化对象

    千次阅读 2017-03-10 14:42:26
    C++如何让类对象只能在堆(栈)上分配空间一般情况下写一个类都是可以采用new在堆...1.静态实例化对象 如 A a;的步骤为:先由编译器为对象在栈空间分配内存,移动栈顶指针,挪出适当的空间,然后在这个空间上调用构造函
  • C++实例化一个类的方式

    千次阅读 2017-06-28 09:55:53
    以上两种方式皆可实现类的实例化,有new的区别在于: 1.前者在堆栈中分配内存,后者为动态内存分配,在一般应用中是没有什么区别的,但动态内存分配会使对象的可控性增强。 2.不加new在堆栈中分配内存 3.大程序用...
  • C++实例化时的内存分配

    千次阅读 2017-05-24 14:55:05
    初学者在学习面向对象的程序设计语言时,或多或少的都些疑问,我们写的代码与最终生编译成的代码却 大相径庭,我们并不知道编译器在后台做了什么工作....首先:我们要知道什么是类的实例化,所谓类的实例化就是在内

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 245,780
精华内容 98,312
关键字:

c++对象实例化

c++ 订阅