8 C++ 中的新成员

目录

• 1 动态内存分配
• 2 命名空间

1 动态内存分配

• C++ 中的动态内存分配

  • C++ 中通过 new 关键字进行动态内存分配
  • C++ 中的动态内存申请是基于类型进行的
  • delete 关键字用于内存释放

  //变量申请
  Type* pointer = new Type;
  //...
  delete pointer;
  
  //数组申请
  Type* pointer = new Type[N];
  //...
  delete[] pointer;
  

• 示例：C++ 中的动态内存分配

  • Demo

    #include <stdio.h>
    
    int main()
    {
        int* p = new int;
        
        *p = 5;
        *p = *p + 10;
        
        printf("p = %p
    ", p);
        printf("*p = %d
    ", *p);
        
        delete p;
        
        p = new int[10];
        
        for(int i=0; i<10; i++)
        {
            p[i] = i + 1;
            
            printf("p[%d] = %d
    ", i, p[i]);
        }
        
        delete[] p;
        
        return 0;
    }
    

  • 编译运行

    p = 0x8218008
    *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
    

• new 关键字与 malloc 函数的区别

  • new 关键字是 C++ 的一部分，malloc 是由 C 库提供的函数
  • new 以具体类型为单位进行内存分配，malloc 以字节为单位进行内存分配
  • new 在申请单个类型变量时可进行初始化，malloc 不具备内存初始化的特性

• 示例：初始化动态内存

  • Demo

    #include <stdio.h>
    
    int main()
    {
        int* pi = new int(1);
        // int* pa = new int[1];
        
        float* pf = new float(2.0f);
        char* pc = new char('c');
    
        printf("*pi = %d
    ", *pi);
        printf("*pf = %f
    ", *pf);
        printf("*pc = %c
    ", *pc);
        
        delete pi;
        delete pf;
        delete pc;
        
        return 0;
    }
    

  • 编译运行

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

2 命名空间

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

  • C 语言中所有的全局标识符共享同一个作用域
  • 标识符之间可能发生冲突

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

  • 命名空间将全局作用域分成不同的部分
  • 不同的命名空间中的标识符可以同名而不会发生冲突
  • 命名空间可以相互嵌套
  • 全局作用域也叫默认命名空间

• C++ 命名空间的定义

  namespace Name
  {
      namespace Internal
      {
          /* ... */
      }
      
      /* ... */
  }
  

• C++ 命名空间的使用

  • 使用整个命名空间：using namespace name;
  • 使用命名空间中的变量：using name::variable;
  • 使用默认命名空间中的变量：::variable;

• 示例：命名空间的使用

  • Demo

    #include <stdio.h>
    
    namespace First
    {
        int i = 0;
    }
    
    namespace Second
    {
        int i = 1;
        
        namespace Internal
        {
            struct P
            {
                int x;
                int y;
            };
        }
    }
    
    int main()
    {
        using namespace First;
        using Second::Internal::P;
        
        printf("First::i = %d
    ", i);
        printf("Second::i = %d
    ", Second::i);
        
        P p = {2, 3};
        
        printf("p.x = %d
    ", p.x);
        printf("p.y = %d
    ", p.y);
        
        return 0;
    }
    

  • 编译运行

    First::i = 0
    Second::i = 1
    p.x = 2
    p.y = 3