c和c++的区别之动态内存开辟、c/c++作用域

一、动态内存开辟

C：malloc，free

C++：new，delete。new的底层调用任然是malloc，但相对于malloc，new具有初始化的功能。对于内置类型可以直接初始化，对于自定义类型，调用构造函数初始化。delete首先会进行析构，然后调用free。

int main(){

内置类型内存的动态开辟：

int* p=(int*)malloc(sizeof(int));

free(p);

int* q=new int(10);

delete q;

一维数组的动态开辟：

int* p=(int*)malloc(sizeof(int)*100);

free(p);

int* q=new int[100];

delete []q;

二维数组的动态开辟：

如3*4：

int main(){

int **p=new int*[3];

for(int i=0;i < 3;++i){

p[i] = new int[4];

}

for(int i=0;i < 3;++i){

delete []p[i];

}

delete []p;

return 0;

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

1.默认的new开辟内存失败，不能以NULL作为判断。当new动态开辟内存失败时，会抛出异常 throw bad_alloc(“”)。

try{

int *p=new int(10);

}

catch(const bad_alloc &err){

}

• 1
• 2
• 3
• 4
• 5
• 6

2.int* p=new (nothrow) int(10);可以通过返回值是否为NULL判断动态开辟是否成功。

3.在堆山开辟常量内存。

在堆上开辟常量内存

const int* p = new const int(10);

const int* q = new const int[10];

• 1
• 2
• 3

4.定位new placement new

char buffer[1000] = {0};

char* p = new (buffer) char[100];//在buff上开辟100字节内存

int* p = new int;

p = new (p) int(10);

int* p=(int*)operator new(sizeof(int)); //malloc

p = new (p) int(10);//初始化

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

二、C/C++作用域

C作用域：

（1）全局作用域

（2）局部作用域

C++作用域：

（1）局部作用域

（2）类作用域

（3）名字空间作用域namespace，又分为局部的名字作用域和全局的名字作用域

#include<iostream>

using namespace std;

//MyName不参与编译，不产生符号

namespace MyName{

int data=10;

int sum(int a,int b){return a+b;}

}

//int data=20;

//using 声明，下边这样的声明方式，一次只能声明一个符号

using MyName::data;

using MyName::sum;

using namespace MyName;//声明整个名字空间MyName中的符号

int main(){

int data=30;

cout<<data<<endl;//优先使用局部的

cout<<::data<<endl;//::全局的作用域符号

cout<<MyName::data<<endl;//MyName名字空间

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

在名字空间定义变量的好处是，可以在不同作用域定义同名的变量，而不致引起冲突。可以定义多个同名的名字空间，在编译的时候进行合并。