Question

new有几种用法?

new有几种用法

Answer 1

1、开辟单变量地址空间

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

2、开辟数组空间

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

扩展资料：

定位放置new的作用：

1、在 C++ 中，通过 new 运算符来实现动态内存分配。new操作符从自由存储区（free store）上为对象动态分配内存空间，凡是通过new操作符进行内存申请，该内存即为自由存储区。

2、new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。

3、new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。

参考资料来源：

百度百科-定位放置new

Answer 2

1、开辟单变量地址空间

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

2、开辟数组空间

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

扩展资料：

定位放置new的作用：

1、在 C++ 中，通过 new 运算符来实现动态内存分配。new操作符从自由存储区（free store）上为对象动态分配内存空间，凡是通过new操作符进行内存申请，该内存即为自由存储区。

2、new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。

3、new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。

参考资料来源：

百度百科-定位放置new

Answer 3

1. new() 分配这种类型的一个大小的内存空间,并以括号中的值来初始化这个变量;

2. new[] 分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这些变量;

#include<iostream>

#include<cstring>

using namespace std;

int main(){

//char* p=new char("Hello");

//error分配一个char(1字节)的空间,

//用"Hello"来初始化,这明显不对

char* p=new char[6];

//p="Hello";

//不能将字符串直接赋值给该字符指针p，原因是：

//指针p指向的是字符串的第一个字符，只能用下面的

//strcpy

strcpy(p,"Hello");

cout<<*p<<endl; //只是输出p指向的字符串的第一个字符！

cout<<p<<endl; //输出p指向的字符串！

delete[] p;

return 0;}

输出结果：

H

Hello

3. 当使用new运算符定义一个多维数组变量或数组对象时，它产生一个指向数组第一个元素的指针，返回的类型保持了除最左边维数外的所有维数。例如：

int *p1 = new int[10];

返回的是一个指向int的指针int*

int (*p2)[10] = new int[2][10];

new了一个二维数组, 去掉最左边那一维[2], 剩下int[10], 所以返回的是一个指向int[10]这种一维数组的指针int (*)[10].

int (*p3)[2][10] = new int[5][2][10]; new了一个三维数组, 去掉最左边那一维[5], 还有int[2][10], 所以返回的是一个指向二维数组int[2][10]这种类型的指针int (*)[2][10].

#include<iostream>

#include <typeinfo>

using namespace std;

int main() {

int *a = new int[34];

int *b = new int[];

int (*c)[2] = new

int[34][2];

int (*d)[2] = new int[][2];

int (*e)[2][3] = new int[34][2][3];

int (*f)[2][3] = new int[][2][3];

a[0] = 1;

b[0] = 1; //运行时错误,无分配的内存,b只起指针的作用,用来指向相应的数据

c[0][0] = 1;

d[0][0] = 1;//运行时错误,无分配的内存,d只起指针的作用,用来指向相应的数据

e[0][0][0] = 1;

f[0][0][0] = 1;//运行时错误,无分配的内存,f只起指针的作用,用来指向相应的数据

cout<<typeid(a).name()<<endl;

cout<<typeid(b).name()<<endl;

cout<<typeid(c).name()<<endl;

cout<<typeid(d).name()<<endl;

cout<<typeid(e).name()<<endl;

cout<<typeid(f).name()<<endl;

delete[] a; delete[] b; delete[] c;

delete[] d; delete[] e; delete[] f;

}

输出结果：

int *

int *

int (*)[2]

int (*)[2]

int (*)[2][3]

int (*)[2][3]

虽然有三种new的用法，但是分为两大类也未尝不可，那么是哪两类呢？其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如：
string* ps = new string("abc");
上面这个new表达式完成了两件事情：申请内存和初始化对象。
new操作符类似于C语言中的malloc，只是负责申请内存，例如：
void* buffer = operator new(sizeof(string));
注意这里多了一个operator。这是new的第二个用法，也算比较常见吧。
那么第三个用法就不很常见了，官方的说法是placement new，它用于在给定的内存中初始化对象，也就是说你手中已有一块闲置的内存，例如：
void* buffer = operator new(sizeof(string));
//那么现在buffer是你所拥有闲置内存的指针
buffer = new(buffer) string("abc"); //调用了placement new，在buffer所指向的内存中初始化string类型的对象，初始值是"abc"
事实上，placement new也是new表达式的一种，但是比普通的new表达式多了一个参数，当然完成的操作和返回值也不同。
因此上面new的第一种用法可以分解两个动作，分别为后面的两种用法。

Answer 4

"1.
new()
分配这种类型的1个大小的内存空间,并以括号中的值来初始化这个变量;
2.
new[]
分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这类变量;
#include<iostream>
#include<cstring>
using
namespace
std;
int
main(){
//char*
p=new
char("Hello");
//error分配1个char(1字节)的空间,
//用"Hello"来初始化,这明显不对
char*
p=new
char[6];
//p="Hello";
//不能将字符串直接赋值给该字符指针p，原因是：
//指针p指向的是字符串的第1个字符，只可以用下边的
//strcpy
strcpy(p,"Hello");
cout<<*p<<endl;
//只是输出p指向的字符串的第1个字符！
cout<<p<<endl;
//输出p指向的字符串！
delete[]
p;
return
0;}
输出结果：
H
Hello
3.
当用new运算符定义1个多维数组变量或数组对象时，它产生1个指向数组第1个元素的指针，返回的类型保持了除最左边维数外的全部维数。例如：
int
*p1
=
new
int[10];
返回的是1个指向int的指针int*
int
(*p2)[10]
=
new
int[2][10];
new了1个二维数组,
去掉最左边那一维[2],
剩下int[10],
因此返回的是1个指向int[10]这种一维数组的指针int
(*)[10].
int
(*p3)[2][10]
=
new
int[5][2][10];
new了1个三维数组,
去掉最左边那一维[5],
还有int[2][10],
因此返回的是1个指向二维数组int[2][10]这种类型的指针int
(*)[2][10].
#include<iostream>
#include
<typeinfo>
using
namespace
std;
int
main()
{
int
*a
=
new
int[34];
int
*b
=
new
int[];
int
(*c)[2]
=
new
int[34][2];
int
(*d)[2]
=
new
int[][2];
int
(*e)[2][3]
=
new
int[34][2][3];
int
(*f)[2][3]
=
new
int[][2][3];
a[0]
=
1;
b[0]
=
1;
//运行时错误,无分配的内存,b只起指针的作用,用来指向相应的数据
c[0][0]
=
1;
d[0][0]
=
1;//运行时错误,无分配的内存,d只起指针的作用,用来指向相应的数据
e[0][0][0]
=
1;
f[0][0][0]
=
1;//运行时错误,无分配的内存,f只起指针的作用,用来指向相应的数据
cout<<typeid(a).name()<<endl;
cout<<typeid(b).name()<<endl;
cout<<typeid(c).name()<<endl;
cout<<typeid(d).name()<<endl;
cout<<typeid(e).name()<<endl;
cout<<typeid(f).name()<<endl;
delete[]
a;
delete[]
b;
delete[]
c;
delete[]
d;
delete[]
e;
delete[]
f;
}
输出结果：
int
*
int
*
int
(*)[2]
int
(*)[2]
int
(*)[2][3]
int
(*)[2][3]
虽然有三种new的用法，可是分为两大类也未尝不可，那么是哪两类呢？其一是new
operator，也叫new表达式；其二是operator
new，也叫new操作符。这2个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如：
string*
ps
=
new
string("abc");
上边这个new表达式完成了两件事情：申请内存和初始化对象。
new操作符类似于C语言中的malloc，只是负责申请内存，例如：
void*
buffer
=
operator
new(sizeof(string));
注意这里多了1个operator。这是new的第二个用法，也算比较常见吧。
那么第三个用法就不很常见了，官方的说法是placement
new，它用于在给定的内存中初始化对象，也就是说你手中已有一块闲置的内存，例如：
void*
buffer
=
operator
new(sizeof(string));
//那么目前buffer是你所拥有闲置内存的指针
buffer
=
new(buffer)
string("abc");
//调出使用了placement
new，在buffer所指向的内存中初始化string类型的对象，初始值是"abc"
事实上，placement
new也是new表达式的一种，可是比普通的new表达式多了1个参数，当然完成的操作和返回值也不一样。
因此上边new的第一种用法可以分解2个动作，分别为后面的两种用法。"