C++ 中的new、malloc、namespace

1，这些新引入的成员想要解决 C 语言中存在的一些问题，

 

2，动态内存分配：

    1，C++ 中的动态内存分配：

       1，C++ 中通过 new 关键字进行基于类型的动态内存申请；

           1，C 语言中自身不包含动态内存分配的内容，通过 malloc 库函数基于字节进行；

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

       3，delete 关键字用于内存释放；

       4，变量申请：

Type* pointer = new Type;

// ......，和 C 语言中的使用方式相同；

delete pointer; 

        5，数组申请：          

Type* pointer = new Type[N];  // N 表示数组包含的元素个数；
// ......,和 C 语言中的使用方式相同；
delete[] pointer;  // 要加上中括号，否则只释放了数组占用的第一个内存空间，剩下的内存空间都没有释放，造成内存泄漏；

      

3，C++ 中的动态内存分配实例分析：

    1，main.cpp 文件：

#include <stdio.h>

int main()
{
    int* p = new int;
    
    *p = 5;
    *p = *p + 10;
    
    printf("p = %p
", p);
    printf("*p = %d
", *p);
    
    delete p;

    printf("p = %p
", p);
    
    p = new int[10];  // p 所指向的这片内存空间至少占用了 40 字节；
    
    for(int i=0; i<10; i++)
    {
        p[i] = i + 1;  // 像数组一样使用；
        
        printf("p[%d] = %d
", i, p[i]);
    }
    
    delete[] p;
    
    return 0;
}

    2，输出结果：

p = 0x9e4e008
*p = 15
p = 0x9e4e008 //这个结果说明，释放的是指向的空间，但是这个时候指针的值还是原来的值；
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

    3，本质上和使用 malloc 和 free 没有太大差异，只不过说在使用体验上变得更好；

 

4，new 关键字与 malloc 函数的区别：

    1，new 关键字是 C++ 的一部分；

    2，malloc 是由 C 库提供的函数；

       1，如果 C 语言编译器无法提供库函数，那么 C 语言编译器无法进行动态内存分配；

    3，new 以具体类型为单位进行内存分配；

    4，malloc 以字节为单位进行内存分配；

    5，new 在申请单个类型变量时可以进行初始化；

       1，这是要注意的区别；

    6，malloc 不具备内存初始化的特性；

       1，calloc 先申请，然后全部设置为 0，这不是真正意义上的初始化；

   

5，new 关键字的初始化： 

    1，代码示例：

int* pi = new int(1);
float* pf = new float(2.0f);
char* pc = new char('c);

   

6，初始化动态内存编程实验：

    1，main.cpp 文件：

#include <stdio.h>

int main()
{
    int* pi = new int(1);  // 申请 int 并初始化为 1；
    // int* pa = new int[1];  // 申请一个 int 大小的数组；
    
    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;
}

   2，输出结果：

     *pi = 1

     *pf = 2.000000

     *pc = c

   

7，C++ 中的命名空间：

    1，在 C 语言中只有一个全局作用域；

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

           1，每个函数的函数体就是局部作用域；

       2，标识符之间可能发生冲突；

           1，工程中能不用全局作用域就不用全局作用域，因为工程上往往很多人同时进行开发，可能造成自己和别人定义的全局变量相冲突，这样会浪费精力解决冲突；

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

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

           1，全局作用域还是只有一个；

           2，不同的部分就是 C++ 概念上的命名空间；

       2，不同的命名空间中的标识符可以同名而不会发生冲突；

           1，最大的意义是可以避免全局作用域当中的同名全局变量发生冲突；

       3，命名空间可以相互嵌套；

           1，命名空间可以细分，即嵌套；

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

      

8，C++ 命名空间的定义：

    1，代码示例：

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

    2，无论如何划分，它们的本质还是全局作用域，也就是说不同的命名空间中所定义的变量和函数还是全局变量和全局函数；

   

9，C++ 命名空间的使用：

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

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

    3，使用默认命名空间中的变量：::variable；

   

10，命名空间的使用实例分析：

    1，main.cpp 文件：

#include <stdio.h>

namespace First  // 将全局作用域进行第一次划分；
{
    int i = 0;  // 全局变量；
}

namespace Second  // 将全局作用域进行第二次划分；
{
    int i = 1;  //全局变量，和上面的 i 不同，因为位于不同的命名空间；
    
    namespace Internal  // 将全局作用域进行第三次划分；
    {
        struct P
        {
            int x;
            int y;
        };
    }
}

int main()
{
    using namespace First;
    using Second::Internal::P;
    
    printf("First::i = %d
", i);  // i 是 First 中的，因为申请了用 First 中的命名空间；
    printf("Second::i = %d
", Second::i);
    
    P p = {2, 3};
    
    printf("p.x = %d
", p.x);
    printf("p.y = %d
", p.y);
    
    return 0;
}

   2，输出结果：

     　First::i = 0

　　 Second::i = 1

　　 p.x = 2

　　 p.y = 3

   

11，小结：

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

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

    3，C++ 中的动态内存分配是基于类型进行的；

       1，C++ 是强类型的语言；

    4，C++ 中命名空间概念用于解决名称冲突问题；