c# new有什么用

new 嘛 \x0d\实例化一个类。 \x0d\比如有一个类叫汽车。你现在想在程序中买一辆，所以你用new来买了一辆汽车，这辆车你得给你找个名字，比如宝马。呵呵所以就成 \x0d\汽车 宝马 = new 汽车 \x0d\\x0d\你有钱了，你要再来一辆 \x0d\\x0d\汽车 奔驰 = new 汽车 \x0d\\x0d\但他们都有汽车该有的东西：四个轮子，一个方向盘，发动机，车门。所以都是汽车一类的东西。 \x0d\\x0d\你看来还没有理解c#的本质，可以这样，c#所有东西全都是类，一个继承另一个，子类继承父类。 \x0d\连string都是个类。申明一个字符串变量，就是实例化一个string类。 \x0d\\x0d\实例化类这个嘛不是c#才有问题，是面向对象的问题。 \x0d\一个包装好了的功能的代码块就可以作为一个类。但你不能直接用它，因为面向对象概念中是不允许随便修改类的内容的。要用你就要实例化。就像汽车这个类。你要用行，但你不能改了汽的一些基本性质上的东西。比如你不能让四个轮子变成只有两个。你不能却掉方向盘。但是你不甘心啊，所以你实例化了，系统就给你一个类似于汽车镜像一样的汽车，他有了汽车通有的东西。你自己给他一个名字，以后你就可以随意让车开开停停，改改装装，你说我要加一排灯行，你可以加在你的实例上，但不要加到类上，因为你一加到类上了，别人实例化了的汽车也有一排的灯了，人家又不喜欢怎么办呢。 \x0d\\x0d\其实你申明字符串变量的时候一般没有用到new因为这种东西有点儿不一样，系统准许你不用new来声明，直接用 \x0d\string 变量名 \x0d\就行了 \x0d\但用new也没有错，一样是可以的。 \x0d\\x0d\c#就是有强大的类库，什么意思呢，就是基本上所有你要完成的程序都可以用c#类库（有很多很多类），实例化你要用的。拼起来就行了。绝大多数类还是要用new的。\x0d\\x0d\在 C# 中，new 关键字可用作运算符或修饰符。 \x0d\\x0d\new 运算符 用于在堆上创建对象和调用构造函数。 \x0d\\x0d\new 修饰符 用于隐藏基类成员的继承成员。 \x0d\\x0d\new 运算符 \x0d\\x0d\1用于创建对象和调用构造函数 \x0d\\x0d\例：Class_Test MyClass = new Class_Test(); \x0d\\x0d\2也用于为值类型调用默认的构造函数 \x0d\\x0d\例：int myInt = new int(); \x0d\\x0d\myInt 初始化为 0，它是 int 类型的默认值。该语句的效果等同于：int myInt = 0; \x0d\\x0d\3不能重载 new 运算符。 \x0d\\x0d\4如果 new 运算符分配内存失败，则它将引发 OutOfMemoryException 异常。 \x0d\\x0d\new 修饰符 \x0d\\x0d\使用 new 修饰符显式隐藏从基类继承的成员。若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它。 \x0d\\x0d\请看下面的类： \x0d\public class MyClass \x0d\\x0d\{ \x0d\\x0d\public int x; \x0d\\x0d\public void Invoke() {} \x0d\\x0d\} \x0d\\x0d\在派生类中用 Invoke 名称声明成员会隐藏基类中的 Invoke 方法，即： \x0d\\x0d\public class MyDerivedC : MyClass \x0d\\x0d\{ \x0d\\x0d\new public void Invoke() {} \x0d\\x0d\} \x0d\\x0d\但是，因为字段 x 不是通过类似名隐藏的，所以不会影响该字段。 \x0d\\x0d\通过继承隐藏名称采用下列形式之一： \x0d\\x0d\1引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。 \x0d\\x0d\2引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。 \x0d\\x0d\3引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。 \x0d\\x0d\4在同一成员上同时使用 new 和 override 是错误的。 \x0d\\x0d\注意：在不隐藏继承成员的声明中使用 new 修饰符将生成警告。 \x0d\\x0d\示例 \x0d\\x0d\在该例中，基类 MyBaseC 和派生类 MyDerivedC 使用相同的字段名 x，从而隐藏了继承字段的值。该例说明了 new 修饰符的使用。同时也说明了如何使用完全限定名访问基类的隐藏成员。 \x0d\\x0d\using System; \x0d\\x0d\public class MyBaseC \x0d\\x0d\{ \x0d\\x0d\public static int x = 55; \x0d\\x0d\public static int y = 22; \x0d\\x0d\} \x0d\public class MyDerivedC : MyBaseC \x0d\\x0d\{ \x0d\new public static int x = 100; // Name hiding \x0d\\x0d\public static void Main() \x0d\\x0d\{ \x0d\\x0d\// Display the overlapping value of x: \x0d\\x0d\ConsoleWriteLine(x); \x0d\\x0d\// Access the hidden value of x: \x0d\\x0d\ConsoleWriteLine(MyBaseCx); \x0d\\x0d\// Display the unhidden member y: \x0d\\x0d\ConsoleWriteLine(y); \x0d\\x0d\} \x0d\\x0d\} \x0d\\x0d\输出 \x0d\\x0d\100 \x0d\\x0d\55 \x0d\\x0d\22 \x0d\\x0d\如果移除 new 修饰符，程序将继续编译和运行，但您会收到以下警告： \x0d\\x0d\The keyword new is required on 'MyDerivedCxbecause it hides inherited member 'MyBaseCx' \x0d\\x0d\如果嵌套类型正在隐藏另一种类型，如下例所示，也可以使用 new 修饰符修改此嵌套类型。 \x0d\\x0d\示例 \x0d\\x0d\在该例中，嵌套类 MyClass 隐藏了基类中具有相同名称的类。该例不仅说明了如何使用完全限定名访问隐藏类成员，同时也说明了如何使用 new 修饰符消除警告消息。 \x0d\\x0d\using System; \x0d\\x0d\public class MyBaseC \x0d\\x0d\{ \x0d\\x0d\public class MyClass \x0d\\x0d\{ \x0d\\x0d\public int x = 200; \x0d\\x0d\public int y; \x0d\\x0d\} \x0d\\x0d\} \x0d\\x0d\public class MyDerivedC : MyBaseC \x0d\\x0d\{ \x0d\\x0d\new public class MyClass // nested type hiding the base type members \x0d\\x0d\{ \x0d\\x0d\public int x = 100; \x0d\\x0d\public int y; \x0d\\x0d\public int z; \x0d\\x0d\} \x0d\\x0d\public static void Main() \x0d\\x0d\{ \x0d\\x0d\// Creating object from the overlapping class: \x0d\\x0d\MyClass S1 = new MyClass(); \x0d\\x0d\// Creating object from the hidden class: \x0d\\x0d\MyBaseCMyClass S2 = new MyBaseCMyClass(); \x0d\\x0d\ConsoleWriteLine(S1x); \x0d\\x0d\ConsoleWriteLine(S2x); \x0d\\x0d\} \x0d\\x0d\} \x0d\\x0d\输出 \x0d\\x0d\100 \x0d\\x0d\200

new 就是实例化，比如实例化一个类，你才能访问，，

好比，你是张三，把你的地址告诉了我，我在能找到你家在哪，这个过程就可以称为实例化。

使用New关键字建立一个新的对象和用它属的类来定义是一样的。New关键字可以被用作来建立一个窗体、类模块以及集合的实例。用户在设计的时候建立的每一个窗体都是一个类。New关键字能够用来建立一个类的实例。

可以通过以下步骤来建立一个类的实例：

(1)在窗体上画一个按钮和几个其他的控件。

(2)按钮的Click事件过程加入以下代码：

Dim x AS New Form1

xShow

(3)运行程序，并且点击几次按钮，把最前面的窗体移开，因为窗体是一个有可视界面的类，此时可以看见有很多窗体的拷贝，每一个窗体具有相同的控件，并且出现在一个地方。

(4)将列代码加到按钮的click事件过程中：

Dim f As Form1

f=New Form1

ftext="hello"

fShow

使用New关键字可以从类模块中定义的类中建立一个新的集合和对象，要知道它们怎样工作，可以参考下面的例子：

(1)建立一个新的工程，并且在一个名为Form1的窗体上画一个按钮控件。

(2)在Project(项目)菜单下，选择"Add Class"给工程添加一个类

(3)把新的类命名为ShowMeVB

(4)在该新类中加入如下代码：

PUblic Class ShowMe

Sub ShowFrm()

Dim frmNew As Form1

frmNew=New Form1

frmNewShow()

frmNewWindowState=1

End Sub

End Class

(5)在Button1_click事件的过程中加入如下代码：Protected Sub Button1_Click(Byval sender As SystemObject,_ Byval AS SystemEventArgs) Dim clsNew As New ShowMe() clsNewShowFrm()End Sub

运行程序，并且点击几次按钮，将看见每创建一个ShowMe类的新的实例时，在桌面上有一个最小化的窗体的图标。

New关键字只能用来建立一个类的对象，不能建立一个基于基本的数据类型的对象，例如Integer。而且，不能建立一个基于一个具体对象的对象。例如，下面的代码根据一个名为SomeClass的类，建立了一个名为Objx的对象，面后又错误地企图根据对象Objx再建立一个其他的对象：

Dim Objx As New SomeClass()

Dim Objx AS New Objx()

以上代码是非法的。

呵呵##~

“new”是C++的一个关键字，同时也是 *** 作符关于new的话题非常多，因为它确实比较复杂，也非常神秘，下面我将把我了解到的与new有关的内容做一个总结

new的过程

当我们使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：获得一块内存空间、调用构造函数、返回正确的指针当然，如果我们创建的是简单类型的变量，那么第二步会被省略假如我们定义了如下一个类A：

class A

{

int i;

public:

A(int _i) :i(_i_i) {}

void Say() { printf(\"i=%d\\n\", i); }

};

//调用new：

A pa = new A(3);

那么上述动态创建一个对象的过程大致相当于以下三句话（只是大致上）：

A pa = (A)malloc(sizeof(A));

pa->A::A(3);

return pa;

虽然从效果上看，这三句话也得到了一个有效的指向堆上的A对象的指针pa，但区别在于，当malloc失败时，它不会调用分配内存失败处理程序new_handler，而使用new的话会的因此我们还是要尽可能的使用new，除非有一些特殊的需求

new的三种形态

到目前为止，本文所提到的new都是指的“new operator”或称为“new expression”，但事实上在C++中一提到new，至少可能代表以下三种含义：new operator、operator new、placement new

new operator就是我们平时所使用的new，其行为就是前面所说的三个步骤，我们不能更改它但具体到某一步骤中的行为，如果它不满足我们的具体要求时，我们是有可能更改它的三个步骤中最后一步只是简单的做一个指针的类型转换，没什么可说的，并且在编译出的代码中也并不需要这种转换，只是人为的认识罢了但前两步就有些内容了

new operator的第一步分配内存实际上是通过调用operator new来完成的，这里的new实际上是像加减乘除一样的 *** 作符，因此也是可以重载的operator new默认情况下首先调用分配内存的代码，尝试得到一段堆上的空间，如果成功就返回，如果失败，则转而去调用一个new_hander，然后继续重复前面过程如果我们对这个过程不满意，就可以重载operator new，来设置我们希望的行为例如：

class A

{

public:

void operator new(size_t size)

{

printf(\"operator new called\\n\");

return ::operator new(size);

}

};

A a = new A();

这里通过::operator new调用了原有的全局的new，实现了在分配内存之前输出一句话全局的operator new也是可以重载的，但这样一来就不能再递归的使用new来分配内存，而只能使用malloc了：

void operator new(size_t size)

{

printf(\"global new\\n\");

return malloc(size);

}

相应的，delete也有delete operator和operator delete之分，后者也是可以重载的并且，如果重载了operator new，就应该也相应的重载operator delete，这是良好的编程习惯

new的第三种形态——placement new是用来实现定位构造的，因此可以实现new operator三步 *** 作中的第二步，也就是在取得了一块可以容纳指定类型对象的内存后，在这块内存上构造一个对象，这有点类似于前面代码中的“p->A::A(3);”这句话，但这并不是一个标准的写法，正确的写法是使用placement new：

[Page]

#include <newh>

void main()

{

char s[sizeof(A)];

A p = (A)s;

new(p) A(3); //p->A::A(3);

p->Say();

}

对头文件<new>或<newh>的引用是必须的，这样才可以使用placement new这里“new(p) A(3)”这种奇怪的写法便是placement new了，它实现了在指定内存地址上用指定类型的构造函数来构造一个对象的功能，后面A(3)就是对构造函数的显式调用这里不难发现，这块指定的地址既可以是栈，又可以是堆，placement对此不加区分但是，除非特别必要，不要直接使用placement new ，这毕竟不是用来构造对象的正式写法，只不过是new operator的一个步骤而已使用new operator地编译器会自动生成对placement new的调用的代码，因此也会相应的生成使用delete时调用析构函数的代码如果是像上面那样在栈上使用了placement new，则必须手工调用析构函数，这也是显式调用析构函数的唯一情况：

p->~A();

当我们觉得默认的new operator对内存的管理不能满足我们的需要，而希望自己手工的管理内存时，placement new就有用了STL中的allocator就使用了这种方式，借助placement new来实现更灵活有效的内存管理

处理内存分配异常

正如前面所说，operator new的默认行为是请求分配内存，如果成功则返回此内存地址，如果失败则调用一个new_handler，然后再重复此过程于是，想要从operator new的执行过程中返回，则必然需要满足下列条件之一：

l

[NextPage]

分配内存成功

l new_handler中抛出bad_alloc异常

l new_handler中调用exit()或类似的函数，使程序结束

于是，我们可以假设默认情况下operator new的行为是这样的：

void operator new(size_t size)

{

void p = null

while(!(p = malloc(size)))

{

if(null == new_handler)

throw bad_alloc();

try

{

new_handler();

}

catch(bad_alloc e)

{

throw e;

}

catch(…)

{}

}

return p;

}

在默认情况下，new_handler的行为是抛出一个bad_alloc异常，因此上述循环只会执行一次但如果我们不希望使用默认行为，可以自定义一个new_handler，并使用std::set_new_handler函数使其生效在自定义的new_handler中，我们可以抛出异常，可以结束程序，也可以运行一些代码使得有可能有内存被空闲出来，从而下一次分配时也许会成功，也可以通过set_new_handler来安装另一个可能更有效的new_handler例如：

[Page]

void MyNewHandler()

{

printf(“New handler called!\\n”);

throw std::bad_alloc();

}

std::set_new_handler(MyNewHandler);

这里new_handler程序在抛出异常之前会输出一句话应该注意，在new_handler的代码里应该注意避免再嵌套有对new的调用，因为如果这里调用new再失败的话，可能会再导致对new_handler的调用，从而导致无限递归调用——这是我猜的，并没有尝试过

在编程时我们应该注意到对new的调用是有可能有异常被抛出的，因此在new的代码周围应该注意保持其事务性，即不能因为调用new失败抛出异常来导致不正确的程序逻辑或数据结构的出现例如：

class SomeClass

{

static int count;

SomeClass() {}

public:

static SomeClass GetNewInstance()

{

count++;

return new SomeClass();

}

};

静态变量count用于记录此类型生成的实例的个数，在上述代码中，如果因new分配内存失败而抛出异常，那么其实例个数并没有增加，但count变量的值却已经多了一个，从而数据结构被破坏正确的写法是：

static SomeClass GetNewInstance()

{

SomeClass p = new SomeClass();

count++;

return p;

}

这样一来，如果new失败则直接抛出异常，count的值不会增加类似的，在处理线程同步时，也要注意类似的问题：

void SomeFunc()

{

lock(someMutex); //加一个锁

delete p;

p = new SomeClass();

unlock(someMutex);

}

此时，如果new失败，unlock将不会被执行，于是不仅造成了一个指向不正确地址的指针p的存在，还将导致someMutex永远不会被解锁这种情况是要注意避免的（参考：C++箴言：争取异常安全的代码）

STL的内存分配与traits技巧

在《STL原码剖析》一书中详细分析了SGI STL的内存分配器的行为与直接使用new operator不同的是，SGI STL并不依赖C++默认的内存分配方式，而是使用一套自行实现的方案首先SGI STL将可用内存整块的分配，使之成为当前进程可用的内存，当程序中确实需要分配内存时，先从这些已请求好的大内存块中尝试取得内存，如果失败的话再尝试整块的分配大内存这种做法有效的避免了大量内存碎片的出现，提高了内存管理效率

为了实现这种方式，STL使用了placement new，通过在自己管理的内存空间上使用placement new来构造对象，以达到原有new operator所具有的功能

template <class T1, class T2>

inline void construct(T1 p, const T2& value)

{

new(p) T1(value);

}

此函数接收一个已构造的对象，通过拷贝构造的方式在给定的内存地址p上构造一个新对象，代码中后半截T1(value)便是placement new语法中调用构造函数的写法，如果传入的对象value正是所要求的类型T1，那么这里就相当于调用拷贝构造函数类似的，因使用了placement new，编译器不会自动产生调用析构函数的代码，需要手工的实现：

[NextPage]

template <class T>

inline void destory(T pointer)

{

pointer->~T();

}

与此同时，STL中还有一个接收两个迭代器的destory版本，可将某容器上指定范围内的对象全部销毁典型的实现方式就是通过一个循环来对此范围内的对象逐一调用析构函数如果所传入的对象是非简单类型，这样做是必要的，但如果传入的是简单类型，或者根本没有必要调用析构函数的自定义类型（例如只包含数个int成员的结构体），那么再逐一调用析构函数是没有必要的，也浪费了时间为此，STL使用了一种称为“type traits”的技巧，在编译器就判断出所传入的类型是否需要调用析构函数：

template <class ForwardIterator>

inline void destory(ForwardIterator first, ForwardIterator last)

{

__destory(first, last, value_type(first));

}

其中value_type()用于取出迭代器所指向的对象的类型信息，于是：

template<class ForwardIterator, class T>

inline void __destory(ForwardIterator first, ForwardIterator last, T)

{

typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;

__destory_aux(first, last, trivial_destructor());

}

//如果需要调用析构函数：

template<class ForwardIterator>

inline void __destory_aux(ForwardIterator first, ForwardIterator last, __false_type)

{

for(; first < last; ++first)

destory(&first); //因first是迭代器，first取出其真正内容，然后再用&取地址

}

//如果不需要，就什么也不做：

tempalte<class ForwardIterator>

inline void __destory_aux(ForwardIterator first, ForwardIterator last, __true_type)

{}

因上述函数全都是inline的，所以多层的函数调用并不会对性能造成影响，最终编译的结果根据具体的类型就只是一个for循环或者什么都没有这里的关键在于__type_traits<T>这个模板类上，它根据不同的T类型定义出不同的has_trivial_destructor的结果，如果T是简单类型，就定义为__true_type类型，否则就定义为__false_type类型其中__true_type、__false_type只不过是两个没有任何内容的类，对程序的执行结果没有什么意义，但在编译器看来它对模板如何特化就具有非常重要的指导意义了，正如上面代码所示的那样__type_traits<T>也是特化了的一系列模板类：

struct __true_type {};

struct __false_type {};

template <class T>

struct __type_traits

{

public:

typedef __false _type has_trivial_destructor;

……

};

template<> //模板特化

struct __type_traits<int> //int的特化版本

{

public:

typedef __true_type has_trivial_destructor;

……

};

…… //其他简单类型的特化版本

如果要把一个自定义的类型MyClass也定义为不调用析构函数，只需要相应的定义__type_traits<T>的一个特化版本即可：

[Page]

template<>

struct __type_traits<MyClass>

{

public:

typedef __true_type has_trivial_destructor;

……

};

模板是比较高级的C++编程技巧，模板特化、模板偏特化就更是技巧性很强的东西，STL中的type_traits充分借助模板特化的功能，实现了在程序编译期通过编译器来决定为每一处调用使用哪个特化版本，于是在不增加编程复杂性的前提下大大提高了程序的运行效率更详细的内容可参考《STL源码剖析》第二、三章中的相关内容

带有“[]”的new和delete

我们经常会通过new来动态创建一个数组，例如：

char s = new char[100];

……

delete s;

严格的说，上述代码是不正确的，因为我们在分配内存时使用的是new[]，而并不是简单的new，但释放内存时却用的是delete正确的写法是使用delete[]：

delete[] s;

但是，上述错误的代码似乎也能编译执行，并不会带来什么错误事实上，new与new[]、delete与delete[]是有区别的，特别是当用来 *** 作复杂类型时假如针对一个我们自定义的类MyClass使用new[]：

MyClass p = new MyClass[10];

上述代码的结果是在堆上分配了10个连续的MyClass实例，并且已经对它们依次调用了构造函数，于是我们得到了10个可用的对象，这一点与Java、C#有区别的，Java、C#中这样的结果只是得到了10个null换句话说，使用这种写法时MyClass必须拥有不带参数的构造函数，否则会发现编译期错误，因为编译器无法调用有参数的构造函数

当这样构造成功后，我们可以再将其释放，释放时使用delete[]：

delete[] p;

当我们对动态分配的数组调用delete[]时，其行为根据所申请的变量类型会有所不同如果p指向简单类型，如int、char等，其结果只不过是这块内存被回收，此时使用delete[]与delete没有区别，但如果p指向的是复杂类型，delete[]会针对动态分配得到的每个对象调用析构函数，然后再释放内存因此，如果我们对上述分配得到的p指针直接使用delete来回收，虽然编译期不报什么错误（因为编译器根本看不出来这个指针p是如何分配的），但在运行时（DEBUG情况下）会给出一个Debug assertion failed提示

[NextPage]

到这里，我们很容易提出一个问题——delete[]是如何知道要为多少个对象调用析构函数的？要回答这个问题，我们可以首先看一看new[]的重载

class MyClass

{

int a;

public:

MyClass() { printf(\"ctor\\n\"); }

~MyClass() { printf(\"dtor\\n\"); }

};

void operator new[](size_t size)

{

void p = operator new(size);

printf(\"calling new[] with size=%d address=%p\\n\", size, p);

return p;

}

// 主函数

MyClass mc = new MyClass[3];

printf(\"address of mc=%p\\n\", mc);

delete[] mc;

运行此段代码，得到的结果为：（VC2005）

calling new[] with size=16 address=003A5A58

ctor

ctor

ctor

address of mc=003A5A5C

dtor

dtor

dtor

虽然对构造函数和析构函数的调用结果都在预料之中，但所申请的内存空间大小以及地址的数值却出现了问题我们的类MyClass的大小显然是4个字节，并且申请的数组中有3个元素，那么应该一共申请12个字节才对，但事实上系统却为我们申请了16字节，并且在operator new[]返后我们得到的内存地址是实际申请得到的内存地址值加4的结果也就是说，当为复杂类型动态分配数组时，系统自动在最终得到的内存地址前空出了4个字节，我们有理由相信这4个字节的内容与动态分配数组的长度有关通过单步跟踪，很容易发现这4个字节对应的int值为0x00000003，也就是说记录的是我们分配的对象的个数改变一下分配的个数然后再次观察的结果证实了我的想法于是，我们也有理由认为new[] operator的行为相当于下面的伪代码：

[Page]

template <class T>

T New[](int count)

{

int size = sizeof(T) count + 4;

void p = T::operator new[](size);

(int)p = count;

T pt = (T)((int)p + 4);

for(int i = 0; i < count; i++)

new(&pt[i]) T();

return pt;

}

上述示意性的代码省略了异常处理的部分，只是展示当我们对一个复杂类型使用new[]来动态分配数组时其真正的行为是什么，从中可以看到它分配了比预期多4个字节的内存并用它来保存对象的个数，然后对于后面每一块空间使用placement new来调用无参构造函数，这也就解释了为什么这种情况下类必须有无参构造函数，最后再将首地址返回类似的，我们很容易写出相应的delete[]的实现代码：

template <class T>

void Delete[](T pt)

{

int count = ((int)pt)[-1];

for(int i = 0; i < count; i++)

pt[i]~T();

void p = (void)((int)pt – 4);

T::operator delete[](p);

}

由此可见，在默认情况下operator new[]与operator new的行为是相同的，operator delete[]与operator delete也是，不同的是new operator与new[] operator、delete operator与delete[] operator当然，我们可以根据不同的需要来选择重载带有和不带有“[]”的operator new和delete，以满足不同的具体需求

把前面类MyClass的代码稍做修改——注释掉析构函数，然后再来看看程序的输出：

calling new[] with size=12 address=003A5A58

ctor

ctor

ctor

address of mc=003A5A58

这一次，new[]老老实实的申请了12个字节的内存，并且申请的结果与new[] operator返回的结果也是相同的

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

1、开辟单变量地址空间

new int;  //开辟一个存放数组的存储空间,返回一个指向该存储空间的地址int a = new int 即为将一个int类型的地址赋值给整型指针a 2)int a = new int(5) 作用同上,但是同时将整数赋值为5。

2、开辟数组空间

要访问new所开辟的结构体空间,无法直接通过变量名进行，只能通过赋值的指针进行访问。用new可以动态开辟,撤销地址空间。在编程序时，若用完一个变量，下次需要再用，可以在每次开始使用时开辟一个空间，在用完后撤销它。

扩展资料：

C++中使用new的注意事项：

1、用户是无法主动调用构造函数的，所以需要借助placement new，但是用户可以主动调用析构函数，所以用完这些对象后，调用析构函数，然后用对应分配内存的方法去释放内存。

2、事实上malloc并不一定比operatornew节省多少时间，用placement new常常是为了考虑性能，所以会配合内存池一起使用。

参考资料来源：百度百科：定位放置new

新的。

new

英［njuː］美［nuː］

adj刚出现的；新的；新近推出的；新东西；新事物；新买的。

［例句］She had come to see the problem in a new light

她开始用新的角度来看待这个问题。

［其他］比较级：newer 最高级：newest。

反义词

old

英［əʊld]美［oʊld]

adj具体年龄；（多少）岁；年纪；老的；年纪大的；不年轻的；老年人。

［例句］The city is dissected by a network of old canals

古老的运河网将这座城市分割开来。

［其他］比较级：older 最高级：oldest。

1、new是一个英文单词，形容词、名词、副词，作形容词时翻译为“新的，新鲜的；更新的；初见的”，作名词时翻译为“人名；(英)纽”，作副词时翻译为“新近”。

2、短语搭配：

New Hampshire新罕布什尔州；新罕布什尔；新罕布夏州

New Order新秩序；新秩序合唱团；新秩序乐队；新订单

New Democracy新民主主义；新民主主义革命

New Media新媒体；新媒介；新传媒；网络传播 

new 相当于给 一个 指针变量 动态分配 内存。类似 C 语言中 的 malloc() 函数。

例如 C++ 程序：

float fp;

fp = new float[10][25][10];

new的作用是实例化。

比如有一种类叫狗类，你要创造一只阿黄，你就得这么创造：

狗类 阿黄=new 狗类（）；

这句话的意思是声明，阿黄是属于狗类这种类的，同时他的名字叫阿黄。

在JAVA语言中，new是实例化，你也可以理解为创造，从一种类中创造出一个真实的个体。

以上就是关于c# new有什么用全部的内容，包括:c# new有什么用、vb.net 中new的具体用法以及实例化是什么意思.、C++语言中，new表示什么的关键字等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！