c++new对象（c++用new创建对象和不用new创建对象的区别解析）

本文目录

• c++用new创建对象和不用new创建对象的区别解析
• c++中使用new创建对象,其生命周期有什么决定由系统决定还是用户控制
• C++怎么用new创建类对象
• 在c++中,同时new一个对象,是不是指向同一块地址
• c++new的用法是怎么样的
• c++中new是什么意思
• C++用new创建类对象问题
• C++中new出来的对象，不delete的话，会怎么样
• c++ 对象声明和new 堆栈的区别

c++用new创建对象和不用new创建对象的区别解析

创建对象的几种方式:
1. 使用动态创建方式，new操作符创建对象。
此时对象是存储在堆区。可以创建非常大的空间（参考计算机的内存大小）。会调用对象的构造函数。
2. 使用动态创建方式，malloc(realloc等)函数创建对象。
此时对象是存储在堆区。可以创建非常大的空间（参考计算机的内存大小）。不会调用对象的构造函数。
3. 使用静态创建方式。
此时对象存放在栈区或者是静态区。会调用对象的构造函数。如果是函数内的局部变量，那么变量的大小受到限制，一般不能超过10M。

c++中使用new创建对象,其生命周期有什么决定由系统决定还是用户控制

• 由用户决定，因为c++ 中没有自动释放池，，new了个新对象 不释放会一直存在内存中

• c++中的new和c中的malloc类似，假如你不delete掉这段申请的内存的话，他会一直存在直到进程结束后系统会回收掉这段资源。而如果你delete了，则这段申请到的内存的生命周期就会从你new了以后到你delete的这段时间

C++怎么用new创建类对象

假设类名字为 T 使用语法 ：T* object = new T(), 其中括号里可以填写类初始化的参数, 得到的 object 是一个T类型的指针，别忘了用delet object 释放内存。
当C++程序用new 分配内存的时候，会比C的malloc 做一些额外的工作，尤其是使得类里面使用的STD标准库类型的变量的到合适的初始化。此外，如果有自己编写的内存管理器，new 还有一个变种: T* object = new (manager) T(), 如果需要, 请参考：
***隐藏网址***

在c++中,同时new一个对象,是不是指向同一块地址

不是的。
比方：int *pi=new int;
此时，表达式在自由存储区分配创建一个整型对象，并返回该对象的地址，而这个地址初始化了指针pi。当你再次运行该表达式时，会再次分配一块存储区，pi就会被新的地址初始化。希望你能理解，祝好运！

c++new的用法是怎么样的

new有三种使用方式：plain new，nothrow new和placement new。

1、plain new，是普通的new，其功能主要是完成对象的初始化。定义如下：

void* operator new(std::size_t) throw(std::bad_alloc);

void operator delete(void *) throw();

提示：plain new在分配失败的情况下，抛出异常std::bad_alloc而不是返回NULL，因此通过判断返回值是否为NULL是徒劳的。

2、nothrow new，是不抛出异常的运算符new的形式。nothrow new在失败时，返回NULL。定义如下：

void * operator new(std::size_t,const std::nothrow_t&) throw();

void operator delete(void*) throw();

3、placement new，即定位放置new，这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

void* operator new(size_t,void*);

void operator delete(void*,void*);

使用方式：

placement new既可以在栈(stack)上生成对象，也可以在堆（heap）上生成对象。不用担心内存分配失败，因为它根本不分配内存，它只是调用对象的构造函数。

使用placement new构造起来的对象或数组，要显式调用它们的析构函数来销毁（析构函数并不释放对象的内存），不能使用delete.这是因为placement new构造起来的对象或数组大小并不一定等于原来分配的内存大小，使用delete会造成内存泄漏或者之后释放内存时出现运行时错误。

c++中new是什么意思

C++中new运算符用于动态分配和撤歼姿散销内存的运算符。

new运算符使用的一般格式为new 类型 。

用new分配数组空间时不能指定初值。如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分配空间是否成功。 

一般来说，使用new申请空间时，是从系统的“堆”（heap）中分配空间。申请所得的空间的位置时根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在程序员指定的特定内存创建对象，这就是所谓的“定位放置new”（placement new）操作。

扩展资料：

1、用定位放置new操作，既可以在栈(stack)上生成对象，也可以在堆（heap）上生成对象。如本例就是在栈上生成一个对象。

2、使用语句A* p=new (mem) A;定位生成对象时，指针p和数组名mem指向同一片存储区。所以，与其说定位放置new操作册改是申请空间，还不如说是利用已经请好的空间，真正的申请空间的工作是在此之前完成的。

3、使用语句A *p=new (mem) A;定位生成对象是，会自动调用类A的构造函数，但是由于对象的空间氏氏不会自动释放（对象实际上是借用别人的空间），所以必须显示的调用类的析构函数，如本例中的p-》~A()。

4、万不得已才使用placement new，只有当你真的在意对象在内存中的特定位置时才使用它。例如，你的硬件有一个内存映像的I/O记时器设备，并且你想放置一个Clock对象在哪那个位置。

参考资料：百度百科-new

C++用new创建类对象问题

MyClass *a = new MyClass 这句伍茄话的意思是创建一个Myclass类型的指针a，并生成腔磨察游猛一个MyClass对象，使指针a指向这个对象。 这个对象是匿名对象没有名字。

C++中new出来的对象，不delete的话，会怎么样

回答追问： main函数执行完，函数退出，进程结束，所有进程占用的内存都会被释放，包括泄露的内存。
main函数执行完，函数退出，进程结束，所有进程占用的内存都会被释放，包括泄露的内存。
　　C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C++支陵纯持多种编脊誉程范式 －－面向对象编程、泛型编程和过程化编程。最新正式标准C++于2014年8月18日公布。其编程领域樱汪段众广，常用于系统开发，引擎开发等应用领域，是至今为止最受广大程序员受用的最强大编程语言之一,支持类：类、封装、重载等特性。

c++ 对象声明和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 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对象