林锐C/C++高质量编程指南之二

char a[] = "hello";
a[0] = ‘X‘;
cout  endl;
char *p = "world";     // 注意 p 指向常量字符串
p[0] = ‘X‘;            // 编译器不能发现该错误 
cout 

char a[] = "hello world";
char *p  = a;  
coutsizeof(a) // 12 字节  
coutsizeof(p) // 4 字节
void Func(char a[100]) 
{
　　cout}

void GetMemory(char *p)
{
    p = (char *)malloc(100); 
} 
void Test(void)  
{ 
    char *str = NULL; GetMemory(str);  
    strcpy(str, "hello world"); 
    printf(str); 
}
请问运行 Test 函数会有什么样的结果？
 答：程序崩溃。 
因为 GetMemory 并不能传递动态内存， 
Test 函数中的 str 一直都是 NULL。 
strcpy(str, "hello world");将使程序崩溃。 

void GetMemory(char **p, int num)
{
    *p = (char *)malloc(num);
}

void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}
请问运行 Test 函数会有什么样的结果？ 
答： （1）能够输出 hello 
    （2）内存泄漏   (没有加free函数)

char *GetMemory(void)
{
    char p[] = "hello world";
    return p;
}

void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
请问运行 Test 函数会有什么样的结果？ 
答：可能是乱码。 
因为 GetMemory 返回的是指向“栈内存” 的指针，
该指针的地址不是 NULL，但其原 现的内容已经被清除，新内容不可知

void Test(void)
{
    char *str = (char *) malloc(100);
    strcpy(str, “hello”);
    free(str);

    if (str != NULL)
    {
        strcpy(str, “world”);
        printf(str);
    }
}
请问运行 Test 函数会有什么样的结果？ 
答：篡改动态内存区的内容，后果难以预料，非常危险。 
因为 free(str);之后，str 成为野指针， if(str != NULL)语句不起作用。 

void GetMemory(char *p)
{
    p = (char *)malloc(100); // 动态内存会自动释放吗   
} 

int  *p1 = (int *)malloc(sizeof(int) * length);
int  *p2 = new int[length];
delete p2;

如果用 new 创建对象数组，那么只能使用对象的无参数构造函数。
Obj  *objects = new Obj[100]; // 创建 100 个动态对象
在用 delete 释放对象数组时，留意不要丢了符号‘[]’。例如
delete []objects; // 正确的用法
delete objects; // 错误的用法 
后者相当于 delete objects[0]，漏掉了另外 99 个对象。

extern “C” 
{
    void foo(int x, int y);
    
    … // 其它函数 
}
或者：

extern “C”
{
    #include “myheader.h” 
     … // 其它 C 头文件
}

class String
{

public:
    String(const char *str = NULL); // 普通构造函数
    String(const String &other); // 拷贝构造函数
    ~ String(void);     // 析构函数
    String &operator =(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(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;
}