内存的三种分配方式：

1． 从静态存储区分配：此时的内存在程序编译的时候已经分配好，并且在程序的整个运行期间都存在。全局变量，static变量等在此存储。

2． 在栈区分配：相关代码执行时创建，执行结束时被自动释放。局部变量在此存储。栈内存分配运算内置于处理器的指令集中，效率高，但容量有限。

3． 在堆区分配：动态分配内存。用new/malloc时开辟，delete/free时释放。生存期由用户指定，灵活。但有内存泄露等问题。

常见内存错误及对策

1． 内存分配未成功，却被使用。

对策：使用内存之前检查是否分配成功。用p!=NULL判断。

2． 内存分配成功，未初始化就被使用。

内存的缺省值没有统一的标准。大部分编译器以0作为初始值，但不完全是。

对策：内存初始化时赋初值。

3． 内存操作越界。

对策：只能是小心了。

4． 释放了内存，仍然使用。

（1）       使用显示delete和free的野指针。

对策：释放完内存，将指针置为NULL。

（2）       使用隐式delete和free的野指针。主要是指函数返回指向栈内存的指针或引用。

对策：当然是不要返回就可以了。

5． 未释放内存，导致内存泄露。

用new/malloc开辟了内存，没用delete/free释放.

对策：new和delete的个数一定相同；malloc和free的个数一定相同；new[]和[]delete一定对应。


示例1：返回指向栈空间的指针

 1char* test1()
 2{
 3    char str[] = "Hello World!";
 4    return str;
 5}
 6
 7char* test2()
 8{
 9    char *str = "Hello World!";
10    return str;
11}
12
13char* test3()
14{
15    static char str[] = "Hello World!";
16    return str;
17}
18
19void main()
20{
21    char *str = NULL;
22    
23        str = test1(); 
24    cout << str << endl; //垃圾信息
25    
26    str = test2(); 
27    cout << str << endl; //ok
28    //str[1] = 'A' ; //error.试图修改常字符串
29         //str = NULL; //error.试图修改常字符串
30
31    str = test3();
32    cout << str << endl;
33}
34

输出结果：
乱码

Hello World!

Hello World!

示例2：new和delete虽然对应，但delete释放不成功

void main()
{
    char* p = new char[4];

    p = "ppp";

    delete []p;
}

运行时错误。P虽然是动态开辟的内存，但在第二条语句后p已经指向了静态存储区上的地址，而对指向静态存储区的指针是不能用delete释放的。此时不仅运行时错误，还有内存泄露。

Portotype:  int printf(char* str, const char* format, parameters);

Writes into the array pointed by str a C string consisting on a sequence of data formatted as the format argument specifies. After the format parameter, the function expects at least as many additional arguments as specified in format.

This function behaves exactly as printf does, but writing its result to a string instead of stdout. The size of the array passed as str should be enough to contain the entire formatted string .

Return value:

On success, the total number of characters written is returned. This count does not include the additional null-character automatically appended at the end of the string.

//Success
//The size of str is long enough
//the number of additional number match with the format
const int size = 25;
char *str = new char[size]; 

   //same as int flag1 = sprintf(str,"%s is written to str.","Test","tEST");
int flag1 = sprintf(str,"%s is written to str.","Test");
//Console: 23-Test is written to str
cout << flag1 << "-" << str << endl; 

On failure, a negative number is returned.

//Failure1
//additional arguments numbers is less than specified is format
//the second %s transmited as unrecognizable words
const int size = 25;
char *str = new char[size]; 
int flag2 = sprintf(str,"%s %s tttttttttttt","Test");
//Console: 19--Test @ tttttttttttt
cout << flag2 << "--" << str << endl;

//Failure2:the size of str is not long enough
   // 在dev c++不能运行，vc6.0沒有问题
const int size = 25;
char *str = new char[size]; 
int flag3 = sprintf(str,"%s jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj","Test");
//VC6.0 Console: Test jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj
//Dev c++: Console: the same as vc6.0 but throws an cannot read memory exception
cout << flag3 << "--" << str << endl;

没有测试出什么时候出错返回负值呢！！谁给我一个例子？

对于指针a,delete a之后，指针a 的地址仍然是原来的地址(并不是NULL)，只不过所指向的对象被释放了，此时指针存放的值为随机的，由编译器确定。

 1     int *a = new int(2);
 2     cout << "after new :" << endl;
 3     cout << "a = " << a << "," << "*a = " << *a << endl;
 4
 5     delete a;
 6     cout << "after delete: " << endl;
 7     if(a == NULL)
 8     {
 9         cout << "a is null after delete" << endl;
10     }
11     else
12     {
13         cout << " a is not null after delete" << endl;
14     }
15     cout << "a = " << a << "," << "*a = " << *a << endl; 

//好的编程习惯
delete a;
a = NULL;

 1class Stu
 2{
 3   public:
 4         Stu(int m):var(m)
 5          { 
 6                  var = m;
 7                  cout << "constructor called." << endl;
 8          }      
 9          ~Stu() { cout << var << " destructor called." << endl;}         
10   private:
11          int var;         
12};
13
14void func()
15{
16       //调用构造函数
17       Stu a(20);
18       //调用默认复制构造函数
19       Stu b(a);     
20       //等价于Stu temp(b); Stu b(temp);  
21       //所以有调用构造函数的过程
22       Stu c = 30;     
23       //都是用隐式方式定义的，所以不用delete,自动调用析构函数
24 |        //注意析构的顺序     
25}
26
27int main()
28{
29   func();   
30   return 0;
31}

 1
 2int main()
 3{
 4
 5    //{
 6       //调用构造函数
 7       Stu a(20);
 8       //调用默认复制构造函数
 9       Stu b(a);     
10       //等价于Stu temp(b); Stu b(temp);  
11       //所以有调用构造函数的过程
12       Stu c = 30;     
13       //new出来的指针对象，必须显示delete,如a,b
14       //类对象结束局部范围后会自动调用析构函数 如c    
15    //}
16    return 0;
17}

 1class Stu
 2{
 3   public:
 4         Stu(int m):var(m)
 5          { 
 6                  var = m;
 7                  cout << "constructor called." << endl;
 8          }      
 9          ~Stu() { cout << var << " destructor called." << endl;}         
10   private:
11          int var;         
12};
13
14void func()
15{
16       //调用构造函数
17       Stu* a = new Stu(20);
18       //调用默认复制构造函数
19       Stu* b= new Stu(*a);     
20       //等价于Stu temp = new Stu(30); Stu b(temp);  
21       //所以有调用构造函数的过程
22       Stu c = 30;     
23       //new出来的指针对象，必须显示delete,如a,b
24       //类对象结束局部范围后会自动调用析构函数 如c
25       delete a;
26       delete b;
27}
28
29int main()
30{
31   func();   
32   return 0;
33}

使用宏和内联函数都可以节省在函数调用方面的时间和空间开销。二者都是为了提高效率，但是却有着显著的区别：
(1)、在使用时，宏只做简单的预处理器符号表(字符串)中的简单替换。而内联函数可以进行参数类型检查，且具有返回值(也能被强制转换为可转换的合适类型)。
(2)、内联函数首先是函数，函数的许多性质都适用于内联函数(如内联函数可以重载)。
(3)、内联函数可以作为某个类的成员函数，这样可以使用类的保护成员和私有成员。而当一个表达式涉及到类保护成员或私有成员时，宏就不能实现了(无法将this指针放在合适位置)。

可以用内联函数完全替代宏。
但是在使用内联函数时也要注意：作为内联函数，函数体必须十分简单，不能包含循环，条件，选择等复杂结构，否则不能作为内联函数。
实际上，编译器的优化系统会自动将一些简单函数变成内联函数。而一些复杂的函数，即使指定为内联，编译器也会自动当作普通函数。

文章出处：DIY部落(http://www.diybl.com/course/3_program/c++/cppxl/20081216/154041.html)