精华内容
下载资源
问答
  • 2018-10-16 16:26:22

    C++中,实例化方式一般有两种:

    1,直接定义对象,这时成员变量需要通过 ‘.' 来访问,如 A a;

    2,定义一个类指针,这时需要用到new方法,如 A *a = new A。访问类的成员函数或者说是成员变量需要通过 ‘->’。但是这个时候,当对象使用完成之后,需要使用delete [] a;把该指针删除。

    怎样选择:

    二者的内存分配方式也不一样,前者在堆栈中分配内存,后者动态分配,动态分配的可控性更强。指针用好了功能强大,因为它可以赋值给全局的变量,这样一下子从局部变量变成全局变量,还能把对象作为返回值。因此,小型的程序直接定义即可,开发大型的项目,还是使用new来实例化 ,但是不要忘记delete就行。

     

    更多相关内容
  • 本文介绍一下 C++类实例化的几种方法。

    欢迎关注我的公众号 [极智视界],获取我的更多笔记分享

    O_o>_<o_OO_o~_~o_O

      本文介绍一下 C++ 中类实例化的几种方法。

      C++ 三大特性:继承、多态和封装都是和类相关的概念,类在 C++ 编程更加的美妙。这里说一下类的几种实例化方法,C++ 中类的实例化动作按存储位置可以分为栈中分配内存和堆中分配内存两种,分别对应不用 new 实例化类和用 new 实例化类。

    1、栈中分配实例化类

      示例一下:

    class Person
    {
    	...;
    }
    
    /// 实例化类
    Person person;
    

      以上完成了不用 new 进行类的实例化,这个时候是在栈中分配内存的,使用完后不需要再手动进行内存的释放,类的析构函数会自动执行内存释放的动作。这样的类实例化方法适用于小类,没有过多的内存管理的动作,使用起来比较便捷。


    2、堆中分配实例化类

      示例一下:

    class Person
    {
        ...;
    }
    
    /// 实例化类
    Person* person = new Person();
    
    /// 释放内存
    delete person;
    

      以上完成了使用 new 进行类的实例化,person 就是指向类 Person 的指针,这个时候内存申请在堆上,记得用完必须手动使用 delete 释放掉内存,因为 delete 和 new 是一对好伙伴,有 new 的地方就得有 delete,不然会造成内存泄漏。


      以上介绍了一下 C++ 中类实例化的的方法。


     【公众号传送】

    《【编程艺术】C++ 类实例化的方法》



    扫描下方二维码即可关注我的微信公众号【极智视界】,获取更多AI经验分享,让我们用极致+极客的心态来迎接AI !

    展开全文
  • 结构体实例(包括共用体)和类实例的初始方法完全相同,二者都可以应用于继承层次中。不同点是结构体(包括共用体)默认成员为public,而默认成员是private型的。  一、若和结构体所有数据成员均为public型...
  • 以上两种方式皆可实现实例化,有new的区别在于: 前者在堆栈中分配内存,后者为动态内存分配,在一般应用中是没有什么区别的,但动态内存分配会使对象的可控性增强。 不加new在堆栈中分配内存 大程序用new,小...

    new创建类对象与不new区别

    A a;
    
    A * a = new a();
    

    以上两种方式皆可实现类的实例化,有new的区别在于:

    1. 前者在堆栈中分配内存,后者为动态内存分配,在一般应用中是没有什么区别的,但动态内存分配会使对象的可控性增强。
    2. 不加new在堆栈中分配内存
    3. 大程序用new,小程序直接申请
    4. 只是把对象分配在堆栈内存中
    5. new必须delete删除,不用new系统会自动回收内存

    起初刚学C++时,很不习惯用new,后来看老外的程序,发现几乎都是使用new,想一想区别也不是太大,但是在大一点的项目设计中,有时候不使用 new的确会带来很多问题。当然这都是跟new的用法有关的。new创建类对象,使用完后需使用delete删除,跟申请内存类似。所以,new有时候又 不太适合,比如在频繁调用场合,使用局部new类对象就不是个好选择,使用全局类对象或一个经过初始化的全局类指针似乎更加高效。

    一、new创建类对象与不new区别
    下面是自己总结的一些关于new创建类对象特点:

    • new创建类对象需要指针接收,一处初始化,多处使用
    • new创建类对象使用完需delete销毁
    • new创建对象直接使用堆空间,而局部不用
    • new定义类对象则使用栈空间
    • new对象指针用途广泛,比如作为函数返回值、函数参数等
    • 频繁调用场合并不适合new,就像new申请和释放内存一样

    二、new创建类对象实例
    1、new创建类对象例子:

    CTest* pTest = new CTest();
    
    delete pTest;
    

    pTest用来接收类对象指针。

    不用new,直接使用类定义申明:

    CTest mTest;
    

    此种创建方式,使用完后不需要手动释放,该类析构函数会自动执行。而new申请的对象,则只有调用到delete时再会执行析构函数,如果程序退出而没有执行delete则会造成内存泄漏。

    2、 只定义类指针
    这跟不用new申明对象有很大区别,类指针可以先行定义,但类指针只是个通用指针,在new之前并为该类对象分配任何内存空间。比如:

    CTest* pTest = NULL;
    

    但使用普通方式创建的类对象,在创建之初就已经分配了内存空间。而类指针,如果未经过对象初始化,则不需要delete释放 。

    3、new对象指针作为函数参数和返回值
    下面是一个例子,不太严谨。主要示意一下类指针对象作为返回值和参数使用。

    class CTest {  public:   int a;  };   
    class CBest {  public:   int b;  };    
    CTest* fun(CBest* pBest) 
    {  
        CTest* pTest = new CTest();
         pTest->a = pBest->b;  
       return pTest;  
    }    
    int main() 
    {  
       CBest* pBest = new CBest();   
       CTest* pRes= fun(pBest);      
       if(pBest!=NULL)    
        delete pBest;  
       if(pRes!=NULL)   
         delete pRes ; 
        return -1; 
    }
    

    堆空间 栈空间

    References:
    https://blog.csdn.net/wujiangguizhen/article/details/30504777

    展开全文
  • C++类实例化时的内存分配

    千次阅读 2017-05-24 14:55:05
    初学者在学习面向对象的程序设计语言时,或多或少的都些疑问,我们写的代码与最终生编译成的代码却 大相径庭,我们并不知道编译器在后台做了什么工作....首先:我们要知道什么是实例化,所谓实例化就是在内
    初学者在学习面向对象的程序设计语言时,或多或少的都些疑问,我们写的代码与最终生编译成的代码却大相径庭,我们并不知道编译器在后台做了什么工作.这些都是由于我们仅停留在语言层的原因,所谓语言层就是教会我们一些基本的语法法则,但不会告诉我们为什么这么做?今天和大家谈的一点感悟就是我在学习编程过程中的一点经验,是编译器这方面的一个具体功能.

    首先:我们要知道什么是类的实例化,所谓类的实例化就是在内存中分配一块地址.

    那我们先看看一个例子:

    #include<iostream.h>
    
    using namespace std;
    
    class a {};
    class b{};
    class c:public a{
    	virtual void fun()=0;
    };
    class d:public b,public c{};
    
    int main()
    {
    	 cout<<"sizeof(a)="<<sizeof(a)<<endl;
    	 cout<<"sizeof(b)="<<sizeof(b)<<endl;
    	 cout<<"sizeof(c)="<<sizeof(c)<<endl;
    	 cout<<"sizeof(d)="<<sizeof(d)<<endl;
    	 return  0;
     }


    程序执行的输出结果为:

    sizeof(a) =1

    sizeof(b)=1

    sizeof(c)=4

    sizeof(d)=8

    为什么会出现这种结果呢?初学者肯定会很烦恼是吗?类a,b明明是空类,它的大小应该为为0,为什么编译器输出的结果为1呢?这就是我们刚才所说的实例化的原因(空类同样可以被实例化),每个实例在内存中都有一个独一无二的地址,为了达到这个目的,编译器往往会给一个空类隐含的加一个字节,这样空类在实例化后在内存得到了独一无二的地址.所以a,b的大小为1.

    而类c是由类a派生而来,它里面有一个纯虚函数,由于有虚函数的原因,有一个指向虚函数的指针(vptr),在32位的系统分配给指针的大小为4个字节,所以最后得到c类的大小为4.

    类d的大小更让初学者疑惑吧,类d是由类b,c派生而来的,它的大小应该为二者之和5,为什么却是8呢?这是因为为了提高实例在内存中的存取效率.类的大小往往被调整到最长元素的整数倍(类似结构体的内存对齐原则),所以应该调整为4的整数倍,即8个字节.

    当然在不同的编译器上得到的结果可能不同,但是这个实验告诉我们初学者,不管类是否为空类,均可被实例化(空类也可被实例化),每个被实例都有一个独一无二的地址.


    下面我们再看一个例子.

    #include<iostream.h>
    
    class a{
    	pivate: 
    	int data;
    };
    
    class b{ 
    	private:
    		int data;
    		static int data1;
    };
    
    int b::data1=0;
     
    void main(){
    	cout<<"sizeof(a)="<<sizeof(a)<<endl;
    	cout<<"sizeof(b)="<<sizeof(b)<<endl;
    }

    执行结果为:

    sizeof(a)=4;

    sizeof(b)=4;

    为什么类b多了一个数据成员,却大小和类a的大小相同呢?因为:类b的静态数据成员被编译器放在程序的一个global  data members中,它是类的一个数据成员.但是它不影响类的大小,不管这个类实际产生了多少实例,还是派生了多少新的类,静态成员数据在类中永远只有一个实体存在,而类的非静态数据成员只有被实例化的时候,他们才存在.但是类的静态数据成员一旦被声明,无论类是否被实例化,它都已存在.可以这么说,类的静态数据成员是一种特殊的全局变量.

    所以a,b的大小相同.

    下面我们看一个有构造函数,和析构函数的类的大小,它又是多大呢?

    #include<iostream.h>
    
    class A{
    	public :
    		A(int a){
    		x=a;}
    		void f(int x){
    		cout<<x<<endl;}
    		~A(){}
    
    	private:
    	   int x;
    	   int g;
    };
    class B{
    	public:
    		private:
    		int  data; int data2;
    		static int xs;
    };
    int B::xs=0;
    
    void  main(){
    	A s(10);
    	s.f(10);
    	cout<<"sizeof(a)"<<sizeof(A)<<endl;
    	cout<<"sizeof(b)"<<sizeof(B)<<endl;
    }


    程序执行输出结果为:

    10 ,

    sizeof(a) 8

    sizeof(b) 8

    它们的结果均相同,可以看出类的大小与它当中的构造函数,析构函数,以及其他的成员函数无关,只与它当中的成员数据有关.调用构造函数和析构函数只需要知道函数的地址即可,而这些函数的地址只与类型有关,而与类型的实例无关,编译器也不会因为这两个实例而在实例内添加任何额外的信息。

    从以上的几个例子不难发现类的大小:

    1.为类的非静态成员数据的类型大小之和.

    2.有编译器额外加入的成员变量的大小,用来支持语言的某些特性(如:指向虚函数的指针).

    3.为了优化存取效率,进行的边缘调整.

    4 与类中的构造函数,析构函数以及其他的成员函数无关.


    总结:  
     
    空的类是会占用内存空间的,而且大小是1,原因是C++要求每个实例在内存中都有独一无二的地址。  
     
    (一)类内部的成员变量: 
     
    普通的变量:是要占用内存的,但是要注意对齐原则(这点和struct类型很相似)。  
    static修饰的静态变量:不占用内存,原因是编译器将其放在全局变量区。  
       
     
    (二)类内部的成员函数:  
     
    普通函数:不占用内存。  
    虚函数:要占用4个字节,用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的,和虚函数的个数是没有关系的。 

    展开全文
  • 首先我们定义一个测试 class Person { private: int age; string name; public: Person() { cout<<"this is construct~"; } Person(int age, string name) { this->age = age; this-
  • C++类实例化方法

    千次阅读 2020-03-15 12:34:08
    C++实例化有两种方式——在栈中实例化和在堆中实例化 在栈中实例化为静态分配内存,不需要手动回收,超出内存系统报错。例如:Student a或者Student a[3],使用“.”操作符,声明即调用了构造函数(已分配了...
  • C++类模板实例化

    千次阅读 2021-09-04 13:32:18
    C++类模板实例化 文章目录C++类模板实例化1. 简介2. 模板实例化2.1 隐式实例化(Implicit instantiation)2.2 显示实例化(Explicit instantiation)2.3 模板中的静态成员 1. 简介 该文章主要总结C++类模板实例...
  • C++实例化的方法

    千次阅读 2020-03-26 12:49:12
    C++实例化的方法 实例化按照在分配内存上面的不同大体分为在:栈中的分配内存和堆中的内存的分配,于是分为下面三种方式。 class CEmployee { private: int age; int id; public: CEmployee() { cout <...
  • 0、前言 在我学了初始化列表的时候,...1、以有参构造的方式实例化类A的对象a,然后换行; 2、这一步是B的有参构造函数,因为有参数,所以将实参a传给形参aa的时候呢,调用了类A的拷贝构造函数; 3、传入参数后并
  • C++的使用:实例化对象

    千次阅读 2021-06-19 10:46:47
    实例化对象有两种方式,一种是在栈上实例化,另一种是在堆上实例化。 示例代码 2 int main() { // 栈上实例化 Student stu1; stu1.setName("jake"); stu1.setAge(15); cout << "My name is " <<...
  • C++类实例化

    千次阅读 2018-07-06 22:22:21
    从栈中请求空间,实例化对象,创建一个坐标的,代码如下:#include&lt;iostream&gt;using namespace std;class Coordinate{ public: int x; int y;void printfX(){ cout&lt;&lt;x&lt;&...
  • c++类实例化的两种方式

    万次阅读 2016-07-16 22:57:40
    //创建类实例方法2:使用指针创建,程序运行完毕后必须释放内存 C *obj2 = new C( "O2" , 22 , 222.0 ); obj2->memberFunction1(); obj2->memberFunction2( 1000 , "C++" ); delete obj2; cout ...
  • C++ 静态成员的内初始详解及实例代码 一般来说,关于C++类静态成员的初始,并不会让人感到难以理解,但是提到C++ 静态成员的”内初始”那就容易迷糊了。 我们来看如下代码: //example.h #include #...
  • C++类实例化对象

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

    万次阅读 多人点赞 2018-07-29 11:45:55
    1、首先定义一个 class Coordinate ...2.实例化一个的对象 void main() { Coordinate coord[3]; //栈上 coord[1].m_iX=10; //在堆中初始化一个实例 Coordinate *p=new Coordinate[3]; //堆中 ...
  • 今天小编就为大家分享一篇关于C++类中变量也可以是引用的代码实例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 1.本身带有无参构造函数 class TestClass { private: int m_Int; int *m_pInt; public: TestClass(){} }; int main() { TestClass *classA1 = new TestClass; TestClass *classA2 = new ...
  • c++ 字符串实例化对象,通过map绑定字符和对象
  • C++ 模板实例化与调用

    万次阅读 2015-10-29 13:13:41
    模板的实例化指函数模板(模板)生成模板函数(模板)的过程。对于函数模板而言,模板实例化之后,会生成一个真正的函数。而模板经过实例化之后,只是完成了的定义,模板的成员函数需要到调用时才会被初始...
  • C++模板实例化

    千次阅读 2020-05-27 10:53:43
    文章目录模板实例化C ++有隐式模板实例化和显式实例1. 上面这种方法叫做隐式实例化2.显示实例化 模板实例化 作为C++模板入门修行者,常常会碰到许多问题。其中一项让我们匪夷所思的就是,日常我们习惯将的定义...
  • 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++如何让对象只能在堆...下面分别来介绍如何定义只能在栈上或堆上实例化。 注: 1.静态实例化对象 如 A a;的步骤为:先由编译器为对象在栈空间分配内存,移动栈顶指针,挪出适当的空间,然后在这个空间上...
  • 1.从栈中实例化对象(花括号中):通过点访问对象,用完,离开花括号,系统就会把分配的内存自动回收 #include &lt;iostream&gt; #include &lt;stdlib.h&gt; using namespace std; class TV { ...
  • 在代码中实际使用模板构造对象或者调用模板函数时,编译器会根据调用者传给模板的实参进行模板类型推导然后对模板进行实例化,此过程中的实例化即是隐式实例化。 template<typename T> T add(T t1, T2) { ...
  • C++之——模板类实例化

    千次阅读 2018-12-06 11:30:44
    模板必须实例化才能作为一个来声明和定义对象,模板实例化成为模板,同一个模板不同的实例之间相互独立,如果模板中有静态成员,则每个模板分别占用一个静态成员 #include&lt;iostream&gt...
  • 主要介绍了C++中COM组件初始方法,涉及C++中COM组件的使用技巧,需要的朋友可以参考下
  • C++函数模板的实例化和具体化

    千次阅读 2020-07-10 18:25:13
    自己关于C++实例化和具体化的简单理解 首先是隐式实例化: template<typename T> void swap(T& a, T& b);//隐式实例化,只有当后面使用到时编译器才进行实例化函数 刚开始创建函数模板时,就是这种情况,...
  • 所以当这个被多次实例化时要知道,并且采取措施防止第二个实例对象去控制wifi模块 可以在构造函数中生命一个静态变量作为标志。 ConnectWifi::ConnectWifi(void) { static bool bFirst = true; /*先判断是不是第...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 334,630
精华内容 133,852
关键字:

c++类的实例化

c++ 订阅