C++ 对象和实例的区别,以及用new和不用new创建类对象区别

本文对比了C++和Java中对象实例化的区别,详细解释了new关键字在C++中的作用及其潜在的问题,同时阐述了Java中对象与对象引用的概念。

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

C++ 对象实例化的一些概念
C++ 如果直接定义类,如classA  a; a存在栈上(也意味着复制了对象a在栈中);
如果classA  a = new classA就存在堆中。

一、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 0;  
}

C++对象实例化

JAVA:
A a = new A();
为A对象创建了一个实例,但在内存中开辟了两块空间:一块空间在堆区,存放new A()这个对象;
另一块空间在堆栈,也就是栈,存放a,a的值为new A()这个对象的内存地址。因为java在JVM中运行,
所以a 描述的内存地址不一定是这个对象真实内存的地址。

Object o; // 这是声明一个引用,它的类型是Object,他的值为null,还没有指向任何对象,该引用放在内存的栈区域中。

o = new Object(); // new Object()句,实例化了一个对象,就是在堆中申请了一块连续空间用来存放该对象。
= // 运算符,将引向o指向了对象。也就是说将栈中表示引用o的内存地址的内容改写成了Object对象在堆中的地址。

C++:
C++ 如果直接定义类,如classA a; a 存在栈上(也意味着复制了对象a在栈中),如果classA a = new classA就存在堆中。

初学Java时,在很长一段时间里,总觉得基本概念很模糊。后来才知道,在许多Java书中,把对象和对象的引用(实例)混为一谈

如果分不清对象与对象引用,那实在没法很好地理解下面的面向对象技术,把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。        

为便于说明,我们先定义一个简单的类:  
class student
{
      int name;
      int age;
      int sex;
}

有了这个类(模板),就可以用它来创建对象:student stu1 = new  student();

通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作

1)右边的"new  student",是以student类为模板,在堆空间里创建一个student类的对象(也简称为student对象)

2)末尾的()意味着,在对象创建后,立即调用student类的构造函数,对刚生成的对象进行初始化

    构造函数是肯定有的。如果你没写,Java会给你补上一个默认的构造函数。

3)左边的"student stu1"创建了一个student类引用变量。所谓student类引用,就是以后可以用来指向某个

    student对象的对象引用,它指向的是某个student对象的内存地址(有点C语言中指针的味道)

4)"="操作符使对象引用指向刚创建的那个student对象

    我们可以把这条语句拆成两部分student  stu1;                 (1)

                                                             stu1 = new student();     (2)

    效果是一样的

    这样写,就比较清楚了,有两个实体:一是对象引用变量(stu1),在Sun公司的实现中,对象的引用是一个句柄,其中包含一对指针:一个指针指向该对象的方法表,一个指向该对象的数据另一个是对象本身(就是new出来的那个对象)

    在堆空间里创建的实体,与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。不仅如此,我们仔细研究一下第二句,想想刚刚创建的student对象叫什么名字?

    有人说,它叫"student"。不对,"student"是类(对象的创建模板)的名字。一个student类可以据此创建出无数个对象,这些对象不可能全叫"student"对象连名都没有,没法直接访问它。我们只能通过对象引用(实例)来间接访问对象

    为了形象地说明对象、对象引用及它们之间的关系,可以做一个或许不很妥当的比喻:

    对象好比是一只没有线的风筝,引用变量是一根线,可以用来系风筝。如果只执行了第一条语句还没执行第二条,此时创建的引用变量stu1还没指向任何一个对象,它的值是null,引用变量可以指向某个对象,或者为null。这时stu1是一根线,一根还没有系上任何一个风筝的线。

   执行了第二句后,一只新风筝做出来了,并被系在stu1这根线上。我们抓住这根线,就等于抓住了那只风筝。

   再来一句:student  stu2;就又做了一根线,还没系上风筝。如果再加一句:stu2=stu1;系上风筝了

   这里,发生了复制行为。但是,要说明的是,对象本身并没有被复制,被复制的只是对象引用

   结果是,stu2也指向了stu1所指向的对象,也就是两根线系的是同一只风筝。

   如果用下句再创建一个对象:stu2=newstudent();则引用变量stu2改指向第二个对象。

   从以上叙述再推演下去,我们可以获得以下结论:

   (1)一个对象引用可以指向0个或1个对象(一根线可以不系风筝,也可以系一个风筝),而且可以改指;

   (2)一个对象可以有N个引用指向它(可以有N条线系同一个风筝)

    如果有下面语句:stu1=stu2;

    按上面的推断,stu1也指向了第二个对象。这个没问题。问题是第一个对象呢?没有一条线系住它,它飞了。

    很多书里说,它被Java的垃圾回收机制回收了,这不确切,准确地说,它已成为Java垃圾回收机制的处理对象。至于什么时候真正被回收,那要看垃圾回收机制的心情了。由此看来,new  student();该语句应该不合法吧,至少是没用的吧?不对,它是合法的,而且可用的。譬如,如果我们仅仅为了打印而生成一个对象,就不需要用引用变量来系住它。最常见的就是打印字符串:System.out.println("Iam Java!");

    字符串对象"I amJava!"在打印后即被丢弃,有人把这种对象称之为临时对象。

最后再说明一下:

C++中:

Student  student(20) ;  //这里student是引用 对象分配在 栈空间中,这里只是我的理解

Student *student = new  Student(20);  //这里student是指针,new Student(20)是分配在堆内存空间的

但是在Java中

Student  student(20) ;  //注意:java中没有这样实例化对象的, 要想得到一个对象 必须要new出来.

Student student ; //这个只是定义了一个引用 ,没有指向任何对象

Student student = new Student(20);   //定义了一个引用,指向堆内存中的student对象


<think>我们正在讨论C++中使用new创建对象与使用对象指针的区别。根据引用内容,可以总结以下几点: 1. **内存分配位置**: - 使用`new`:在堆(heap)上动态分配内存。堆是向高地址扩展的数据结构,空间较大(例如可达2GB或更多),但分配释放需要手动管理(使用`delete`),效率相对较低。 - 不使用`new`(即直接创建对象):在栈(stack)上分配内存。栈空间有限,但分配释放由系统自动管理,效率高。 2. **生命周期管理**: - 使用`new`:对象的生命周期由程序员控制,必须显式调用`delete`释放内存,否则会导致内存泄漏。只有调用`delete`时才会执行析构函数。 - 不使用`new`:对象在离开作用域时自动销毁(调用析构函数),无需手动释放。 3. **对象使用方式**: - 使用`new`:返回一个指向堆上对象的指针,通过指针访问对象成员(使用`->`操作符)。 - 不使用`new`:直接使用对象名访问成员(使用`.`操作符)。 4. **指针的使用**: - 引用[3]指出,创建指针对象而不初始化是危险的(“耍流氓”)。建议先创建一个普通对象实例),然后用指针指向它。这样可以避免空指针访问,同时利用指针的灵活性(例如,指向不同的对象)。 5. **性能考虑**: - 在频繁调用的场合(如循环中),在栈上创建对象(不使用`new`)通常更高效,因为栈的分配释放速度快。而使用`new`在堆上分配会带来额外的开销。 6. **适用场景**: - 使用`new`:当对象很大,或者需要在多个作用域共享,或者需要动态确定对象数量(如数组)时。 - 不使用`new`:对象较小,生命周期明确(如局部变量),不需要共享时。 ### 示例代码说明 #### 使用`new`创建对象 ```cpp class MyClass { public: MyClass() { cout << "Constructor" << endl; } ~MyClass() { cout << "Destructor" << endl; } void method() { cout << "Method" << endl; } }; int main() { // 使用new在堆上创建对象 MyClass* obj = new MyClass(); obj->method(); // 通过指针访问成员 delete obj; // 必须手动释放 return 0; } ``` 输出: ``` Constructor Method Destructor ``` #### 不使用`new`创建对象 ```cpp int main() { // 在栈上创建对象 MyClass obj; obj.method(); // 通过对象名访问成员 return 0; } // 对象自动销毁 ``` 输出: ``` Constructor Method Destructor ``` #### 指针指向已存在的对象 ```cpp int main() { MyClass stackObj; // 栈上对象 // 指针指向栈上对象(注意:栈对象生命周期仅在作用域内) MyClass* p = &stackObj; p->method(); return 0; } // stackObj自动销毁,p变为悬空指针(但此时已离开作用域,p也不存在) ``` ### 注意事项 1. **内存泄漏**:使用`new`后忘记`delete`会导致内存泄漏[^4]。 2. **悬空指针**:指针指向的对象被销毁后(如栈对象离开作用域),指针变为悬空指针,再次访问会导致未定义行为。 3. **智能指针**:现代C++推荐使用智能指针(如`std::unique_ptr`、`std::shared_ptr`)管理动态分配的内存,避免手动`delete`。 ### 总结对比表 | 特性 | 使用`new`(堆对象) | 不使用`new`(栈对象) | |--------------|-----------------------------|---------------------------| | **内存位置** | 堆(大空间,不连续) | 栈(小空间,连续) | | **生命周期** | 由程序员控制(需`delete`) | 作用域结束自动销毁 | | **性能** | 分配/释放较慢 | 分配/释放快 | | **访问方式** | 通过指针(`->`) | 直接访问(`.`) | | **适用场景** | 大对象、共享对象、动态数组 | 小对象、局部临时对象 | §§相关问题§§ 1. C++中智能指针如何帮助管理动态内存? 2. 在C++中,如何避免悬空指针问题? 3. 栈对象对象在函数返回时有何不同? </think> ### C++中使用`new`创建类对象与使用对象指针的区别 #### 一、核心概念对比 | **特性** | **使用`new`创建对象** | **直接创建对象(不使用`new`)** | |------------------|-----------------------------------------------|------------------------------------------| | **内存位置** | 堆(Heap)空间 | 栈(Stack)空间 | | **生命周期** | 需手动管理(`delete`释放) | 自动管理(离开作用域销毁)[^2] | | **访问方式** | 通过指针(`->`操作符) | 直接访问(`.`操作符) | | **内存开销** | 额外指针存储(固定4/8字节) | 仅对象本身大小 | | **适用场景** | 大对象/动态分配/跨作用域共享 | 小对象/局部变量/短生命周期 | #### 二、技术细节分析 1. **内存分配机制** - `new`对象:在堆上动态分配,空间大但分配速度慢 ```cpp MyClass *obj = new MyClass(); // 堆分配 ``` - 直接对象:在栈上自动分配,速度快但空间有限 ```cpp MyClass obj; // 栈分配(自动调用构造函数) ``` 2. **生命周期管理** - `new`对象:必须显式释放,否则内存泄漏 ```cpp delete obj; // 手动释放(调用析构函数) ``` - 直接对象:离开作用域时自动析构 ```cpp { MyClass obj; // 进入作用域构造 } // 离开作用域自动析构 ``` 3. **指针使用规范** - 未初始化的指针对象是危险操作(引用[3]警告): ```cpp MyClass *p; // 危险:未初始化指针 p->method(); // 未定义行为(可能崩溃) ``` - 正确做法:指针指向有效对象 ```cpp MyClass baseObj; // 创建实际对象 MyClass *p = &baseObj; // 指针指向有效对象[^3] ``` #### 三、性能差异 1. **时间效率** - 栈分配:常数时间 $O(1)$(仅移动栈指针) - 堆分配:非确定性时间(可能触发GC或系统调用) 2. **空间效率** - 指针对象额外开销: $$ \text{总内存} = \text{对象大小} + \text{指针大小}(4/8\text{字节}) $$ 验证代码: ```cpp cout << sizeof(int*) << endl; // 输出4(32位)或8(64位) cout << sizeof(MyClass*) << endl; // 始终为4/8字节[^4] ``` #### 四、最佳实践场景 | **场景** | **推荐方式** | **原因** | |------------------------|-------------------|--------------------------------------| | 高频创建的小对象 | 直接创建对象 | 避免堆分配开销[^2] | | 对象需跨函数传递 | `new`创建+指针传递 | 避免拷贝开销 | | 多态场景 | 基类指针+`new`派生 | 实现运行时绑定 | | RAII资源管理 | 智能指针+`new` | 自动释放内存(如`std::unique_ptr`) | #### 五、典型错误示例 ```cpp // 错误1:内存泄漏 void createLeak() { MyClass *obj = new MyClass(); // 忘记delete → 内存泄漏 } // 错误2:悬空指针 MyClass* dangerous() { MyClass localObj; return &localObj; // 返回栈对象指针 → 悬空指针! } // 错误3:重复释放 MyClass *obj = new MyClass(); delete obj; delete obj; // 二次释放 → 程序崩溃 ```
评论 5
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值