C++学习笔记（7）动态内存&命名空间

动态内存

• 函数内部声明的变量都放入栈中
• 当调用子函数的过程中，压栈顺序是变量从右往左压栈，一般放的都是参数值以及局部变量
• 此外还有代码区，公共变量存储区，define以及static变量都压入公共变量存储区
• 栈在高地址，堆在低地址，栈的生长方向是往低地址生长，堆是向高地址生长
• 在C中申请动态内存使用的是malloc关键字，但是在C++中使用的是new
• 释放内存时，C使用的是free关键字，C++使用的是delete关键字
  申请动态内存的用法：
  例如

int *a;
a=new int;  //new后面可以跟数组，系统的数据类型，自定义的数据类型
delete a;   //删除申请的动态内存

数组的情况：

int *a;
a=new int[10];     //后面直接跟数据
delete[] a;       //使用delete[]删除数组

以上是一维数据，碰到多维数据时，需要使用类似于链表一样的赋值方式，例如：

int ***a;  // a[m][n][h];
int m=10,n=10,h=10;
int i,j,k;
a=new int **[m];
for(i=0;i<m;i++)
{
  a[i]=new int *[n];
  for(j=0;j<n;j++)
  {
    a[i][j]=new int[h];
  }
}
//释放内存
for(i=0;i<m;i++)
{
  for(j=0;j<n;j++)
  {
    delete[] a[i][j];
  }
}
delete[] a;

delete和delete []的区别：
前者只能释放一个翻译的内存空间，如果用delete释放一个int a[10]的数组，那么只会释放a[0]不会释放后面的，只有用delete[]才能够释放所有的数组，所以有数组久用[]没有就不加

#include <iostream>
using namespace std;

class Box
{
public:
    Box() {
        cout << "调用构造函数！" << endl;
    }
    ~Box() {
        cout << "调用析构函数！" << endl;
    }
};

int main()
{
    Box** myBoxArray = new Box *[2];
    for (int a = 0; a < 2; a++)
    {
        myBoxArray[a] = new Box[3];
    }
    for (int b = 0; b < 2; b++)
    {
        delete[] myBoxArray[b]; // 删除数组
    };
    delete[] myBoxArray;    //删除头部
    return 0;
}

运行结果

调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！

命名空间

命名空间主要针对库中函数重名问题，而虚函数主要是针对继承过程中函数重名的问题。
命名空间主要是添加附加信息来区分不同库中相同名称的函数、类、变量等
命名空间的命名方式：

namespace name   //声明
{
   int test（）{；}
}
int b=name::test();

也可以使用using关键字，当只有一个using的时候，默认后面的语句都是使用这个命名空间，使用两个using namespace XX的时候，如果两个命名空间中有两个相同函数或者变量，仍然需要使用name::YY这样的访问方式，也就是说，使用using之后，其作用范围是整个的后面，日如果有多个using，那么就会重合。

此外如果命名空间中的某个组成部分需要请求定义在另一个文件中的名称，则仍然需要声明该名称。

例子

#include <iostream>
using namespace std;
using std::cout;              //这是表明只是用std中的cout，可以相同的方式使用其他变脸，函数等
// 第一个命名空间
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }
}
// 第二个命名空间
namespace second_space {
    void func() {
        cout << "Inside second_space" << endl;
    }
}
using namespace first_space;
int main()
{

    // 调用第一个命名空间中的函数
    func();
    using namespace second_space;              //往后的函数都可以使用使用两个命名空间中的内容
    second_space::func();                       //前面不加修饰的话不知道其真正的函数，会报错
    return 0;
}

嵌套命名空间
namespace可以嵌套进行定义其方式如下：

namespace one
{
   func
   namespace two
   {
      func
      namespace three
      {
         func
      }
   }
}

当使用的时候如果不用using的时候如果要访问three中的func那么方式是两个
1 using访问
using namespace one //只访问one中的func
using namespace one::two //只访问two中的func
using namespace one::two::three //只访问three中的func

之后使用func
2、直接访问
one::func;
one::two:func;
one::two::three::func;
例子：

#include <iostream>
using namespace std;
using std::cout;
namespace san_space {
    void func() {
        cout << "Inside san_space" << endl;
    }
    namespace si_space {
        void func() {
            cout << "Inside si_space" << endl;
        }
        namespace wu_space {
            void func() {
                cout << "Inside wu_space" << endl;
            }
        }
    }

}
using namespace san_space::si_space::wu_space;
int main()
{

    // 调用第一个命名空间中的函数
    //san_space::si_space::wu_space::func();
    func();
    return 0;
}

输出：

Inside wu_space