内存分配

内存分配方式有三种：

（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

void GetMemory2(char **p, int num) {

*p = (char *)malloc(sizeof(char) * num); }

void Test2(void) {

char *str = NULL;

GetMemory2(&str, 100); // 注意参数是 &str，而不是str strcpy(str, \"hello\"); cout<< str << endl; free(str); }

char *GetMemory3(int num) {

char *p = (char *)malloc(sizeof(char) * num); return p; }

void Test3(void) {

char *str = NULL;

str = GetMemory3(100); strcpy(str, \"hello\"); cout<< str << endl; free(str); }

char *GetString2(void) {

char *p = \"hello world\"; return p; }

void Test5(void) {

char *str = NULL; str = GetString2(); cout<< str << endl; }

class String {

public:

String(const char *str = NULL); // 普通构造函数 String(const String &other); // 拷贝构造函数 ~ String(void); // 析构函数

String & operate =(const String &other); // 赋值函数 private:

char *m_data; // 用于保存字符串 };

// String 的普通构造函数

String::String(const char *str) {

if(str==NULL) {

m_data = new char[1]; *m_data = ‘\\0’; } else {

int length = strlen(str); m_data = new char[length+1]; strcpy(m_data, str); } }

// String 的析构函数

String::~String(void) {

delete [] m_data;

// 由于m_data 是内部数据类型，也可以写成 delete m_data; }

// 拷贝构造函数

String::String(const String &other) {

// 允许操作other 的私有成员m_data int length = strlen(other.m_data); m_data = new char[length+1]; strcpy(m_data, other.m_data); }

// 赋值函数

String & String::operate =(const String &other) {

// (1) 检查自赋值 if(this == &other) return *this;

// (2) 释放原有的内存资源 delete [] m_data;

// （3）分配新的内存资源，并复制内容 int length = strlen(other.m_data); m_data = new char[length+1]; strcpy(m_data, other.m_data); // （4）返回本对象的引用 return *this; }