动态内存分配

C++中的动态内存分配

C++中通过new关键字进行动态内存申请

C++中的动态内存申请是基于类型进行的

delete关键字用于内存释放

include <stdio.h>

int main()
{
    int* p = new int;
    
    *p = 5;
    *p = *p + 10;
    
    printf("p = %p\n", p);
    printf("*p = %d\n", *p);
    
    delete p;
    
    p = new int[10];
    
    for(int i=0; i<10; i++)
    {
        p[i] = i + 1;
        
        printf("p[%d] = %d\n", i, p[i]);
    }
    
    delete[] p;
    
    return 0;
}

输出：

p = 0x8f74008
*p = 15
p[0] = 1
p[1] = 2
p[2] = 3
p[3] = 4
p[4] = 5
p[5] = 6
p[6] = 7
p[7] = 8
p[8] = 9
p[9] = 10

例：

#include <stdio.h>
int main(int argc, char *argv[])

{

     int* pi = new int(1);

     float* pf = new float(2.0f);

     char* pc = new char('c');

     printf("*pi = %d\n",*pi);

     printf("*pf = %f\n",*pf);

     printf("*pc = %c\n",*pc);

     delete pi;pf;pc;

     return 0;

}

输出：

*pi = 1
*pf = 2.000000
*pc = c

注意区别：

int* p = new int(1); //申请int类型的内存
int* pa = new int[1];//申请int类型的内存空间，空间变量为1；

C++中的命名空间

C语言中只有一个全局作用域

C语言中所有的全局标识符共享同一个作用域

标识符之间可能发生冲突

C++中提出了命名空间的概念

不同命名空间将全局作用域分成不同的部分

命名空间可以相互嵌套

全局作用域也叫默认命名空间

小标题

C++命名空间的使用

使用整个命名空间：using namespace name;

使用命名空间中的变量：using namespeace name::variable;

使用默认命名空间中的变量： ：：variable

例：

#include <stdio.h>
namespace frist
{
   int i = 50;
}
namespace second
{
  int  i = 100;
   namespace internal
   {
     struct P
     {
       int x;
       int y;
     };
    
   }
}

int main(int argc, char *argv[])
{   
    using namespace frist;
    using namespace second;
    using second::internal::P;
    using namespace second::internal;
    using namespace second::internal;
    P ss = {2,3};
    printf("second::i= %d\n",frist::i);
    printf("frist::i= %d\n",second::i);
    printf("ss.x= %d\n",ss.x);
    printf("ss.y= %d\n",ss.y);

    return 0;

}

输出：

second::i= 50
frist::i= 100
ss.x= 2
ss.y= 3

小结：

C++中内置了动态内存分配的专用关键字

C++中动态内存分配可以同时进行初始化

C++中的动态内存空间分配基于类型进行的

C++中命名空间用于解决名称冲突的问题

小结：