内存的三种分配方式：

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)

★为什么用static成员而不是全局对象？

       ---- static对象名字在类作用域中，可以有效避免命名冲突，并且清晰显示程序意图。

       ---- 可以实施封装（static成员可以定义为private，而全局对象不可以）

★ 如何调用？     ---- class A a; A::static_mem; a.static_mem;

★ 声明和定义

       ---- static成员函数在类定义体内部外部定义均可。在类定义体外定义时不加（不可以加）static修饰。

       ---- static数据成员必须在类定义体外部定义（正好一次）(在类定义体外声明并定义)

              class A{public : static int n;} int A::n = 10;

       ---- const static数据成员可以（也可以不）在类定义内初始化，但必须在类定义体外部重新声明（不可以加static修饰符，不可以赋初值）

★ static数据成员其他特性：

       ----一般地，在类的内部不能有该类类型的变量（或函数形参），最多只能有该类类型的指针或引用做变量类型（或函数形参）.  static数据成员则不受这个限制。

       ---- 类的static数据成员可以作为函数默认实参 

       ---- static成员的继承：如果基类有static成员，则整个继承层次中只有一个这样的成员。每个static成员总是只有一个实例。
     

 1#include <iostream> 
 2#include <cstdlib>
 3
 4using namespace std; 
 5
 6class A
 7{
 8      //重载输出操作符 
 9      friend ostream& operator<<(ostream& out, const A&a)
10      {
11             out << a.m;
12             return out;
13      }
14      
15private:
16        int m ;
17 
18public:
19       A(int i) { m = i;}
20       
21       static int n;  
22       
23       static A a; //类可以有该类类型的static成员
24       //A a1; //error. 类不可以有普通的该类类型的成员            
25       
26       static void func(A a) {cout << a << endl;} //类类型可以作为该类static函数的形参   
27       
28       //static 数据成员可以作为类成员函数的默认实参 
29       static void func2(int i = n) { cout << i*i <<endl;}    
30};
31
32int A::n = 10;
33A A::a(1);
34
35int main()
36{
37    cout << A::n << endl; //10
38    cout << A::a <<endl; //1
39    
40    A a2(3); 
41    A::func(a2); //3
42    A::func2(); //100
43 
44    system("pause");
45    return 0;
46} 

1.多重继承下的类作用域名字查找规则：第一步，编译器找到一个匹配的声明。如果匹配的声明不止一个，则导致二义性，出错；第二步，编译器确定找到的名字是否合法。

避免二义性的方法：在解决二义性的派生类中定义函数的一个版本。

2. 采用虚继承的方法可以有效减少二义性。定义虚继承的方法，在派生列表中包含“virtual”。

虚继承中名字查找方法。设查找函数func：（1）如果在每个路径中func表示同一基类成员，则没有二义性，因为类共享该成员的单个实例。（2）如果在某个路径中func是虚基类的成员，而在另一路径上是后代派生类的成员，也没有二义性，因为特定派生类实例的优先级高于共享虚基类实例。（3）如果沿每个继承路径func表示后代派生类的不同成员，则具有二义性。

3.虚继承的特殊初始化方式。通常，每个类只初始化自己的直接基类。但在虚继承中也这样运行的话，可能会多次初始化虚基类。

由最低层（非虚继承）派生类的构造函数初始化虚基类。（2）任何直接或间接继承虚基类的类一般也必须为该虚基类提供自己的初始化式，以提供自身对象初始化使用。

class ZooAnimal{...};

class Bear: public virtual ZooAnimal{...};

class Raccoon: public virtual ZooAnimal{...};

class Endangered{...};

class Panda: public Bear,public Raccoon,public Endangered{...};

在上面的例子中，Panda构造函数初始化Panda，ZooAnimal,Bear,Raccoon,Endangered部分，供Panda对象使用。Bear（or Raccoon）构造函数初始化Bear(or Raccoon),ZooAnimal部分供Bear(or Raccoon)对象使用.

4. 虚继承的构造函数次序。先是全部直接基类的虚基类的构造函数按声明的顺序，然后是非虚基类函数按声明的顺序运行。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!267.entry

template<class cl, class T>

cl func(cl* cl_p, T value)

{

       //cl::size_type * value; // If cl::size_type is a type, then a declaration

                        // If cl::size_type is an object, then a multiplication

typename cl::size_type *value;

}                           

2. 非类型模板形参的使用: 模板非类型形参是模板定义内部的常量值.(在需要常量表达式的时候,可以用非类型形参,如定义数组的长度)。

因为非类型模板形参需要传递的是常量表达式，所以不支持一般的隐式类型转换。

template<class T, size_t N> void fcn(T (&cl)[N]) {...}

int x[20];

fcn(x);

3. 模板何时实例化？函数声明，定义对象的引用和指向对象的指针都不会实例化。定义类对象或调用函数时实例化。

4.friend模板声明依赖性：（1） 当授予对给定模板所有实例的访问权时，在作用域中不需要存在该类模板或函数模板的声明。编译器将友元声明也当作类或函数的声明对待；（2）想要限制对特定实例化的友元关系时，必须在可以用于友元声明之前声明类或函数。

5.对于不同参数的函数模板用相同参数可以调用么？可以，会调用隐式转换。

#include<iostream>

using namespace std;

template<typename T1, typename T2>

void print(const T1 &v1, const T2 &v2)  //参数类型不同
{
    cout << "T1 = " << v1 <<endl;
    cout << "T2 = " << v2 <<endl;
}

int main()
{
    print(1,2); //ok

    int a=1;
    int b=2;
    print(a,b); //ok，形参类型相同

    return 0;
}
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!266.entry

//template.cpp
template<typename T>
void print(const T &v)
{
    cout << "T = " << v <<endl;
}

//template.h
#ifndef TEMPLATE_H
#define TEMPLATE_H

template<typename T>
void print(const T &v);

#include "template.cpp" 

#endif

//main.cpp
#include<iostream>
#include "template.h"   //#include"template.cpp" 用这条命令代替也可以。

using namespace std;

int main()
{
    print(1); //ok
    return 0;
}

2. 分别编译模型（seperate compilation model）.函数声明和类定义放在头文件中，带export关键字的函数定义和类声明放在源文件中。源文件尾包含头文件。（不知道理解的对不对，用的编译器不支持分别编译，暂时无从判断了）

//the template definition goes in a separately-compiled source file

export template<typename T>

T print(const T&v) /*...*/

//class template header goes in shared header file

template <class T> class cl{...};

//cl.cpp implementation file declares cl as exported

export template <class T> class cl;

#include "cl.h"

//cl member definitions

文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!265.entry

基类析构函数应定义为virtual，复制操作符一般定义为非virtual

在基类构造函数和析构函数中，将派生类对象当作基类类型对象对待。（因为在这两个函数的运行过程中，对象不是一个完整的派生类类型）

类的复制控制的三法则有个例外：定义（空）虚构够函数时可以不定义构造函数和赋值函数。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!264.entry

对于后代类和用户代码：

public继承时：后代类和用户代码都可以。

protected继承时：后代类可以，用户代码不可以。

private继承时：后代类和用户代码都不可以。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!263.entry

2.派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限。

#include<iostream>
using namespace std;

class Base
{
public:
    Base():i(0),j(0){};
protected:
    int i;
private:
    int j;
};

class Derived:public Base
{
    Derived():Base(){};

    print(const Base &b, const Derived &d)
    {
        int num = i;
        //num = b.i; //error. cannot access protected member declared in class 'Base'
        num = d.i;
        //num = d.j; //error. cannot access private member declared in class 'Base'
    };
};

int main()
{
    return 0;
}
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!262.entry

任何时候编译器都会合成析构函数，并且合成的析构函数总会运行。

撤销容器（标准库容器和内置数组）是按逆序进行的。

内存泄漏（Memory leak）：删除指向动态分配内存的指针失败，因而无法将该块内存返还给自由存储区，这样的删除动态分配内存失败称为内存泄漏。

只有当删除指向类对象的指针时才会运行该对象的析构函数。如果不删除指针，则对象一直存在，导致内存泄漏。

三法则（rule of three）：如果类需要析构函数，则也需要赋值操作符和复制构造函数。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!255.entry

初始化列表：通常使用初始化是为了提高效率，它直接调用与实参匹配的构造函数。【因为一般在构造函数体内的复制也经过初始化-->计算赋值（此时会调用复制构造函数）两个阶段】；特别的有些时候只能用初始化列表，即不能赋值的参数，如：const或引用类型的成员，没有默认构造函数的类类型成员。初始化列表中变量的初始化顺序是先声明的先初始化.

class cl1{ private: const int ci;  int &ri;}; //ci,ri只能在初始化列表中进行初始化。

默认构造函数：全部形参是默认实参的构造函数也是默认构造函数。

只要自己定义了（任意的）构造函数，编译器就不会为我们合成默认构造函数。

复制构造函数：单个形参为本类类型对象的引用的构造函数。对于不支持复制的类型（如IO类型）不能用复制构造函数。如果自己定义了复制构造函数（而不是构造函数，即：只定义构造函数，但没有定义复制构造函数，则编译器合成复制构造函数），则编译器不会合成复制构造函数。【复制构造函数需要特别注意指针成员，以后将说明】

ifstream file1("filename1"); //ok, direct initialization.

ifstream file2="filename2"; //error

如何防止复制：可以通过将复制构造函数声明为private来禁止普通函数（非成员，非友元函数）的访问；可以通过声明一个private复制构造函数而不对其定义来禁止成员函数和友元函数的访问。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!254.entry

mutable数据成员：任何函数（包括类const成员函数）都可以修改mutable数据成员。

explicit构造函数：声明时指定，定义时不允许重复指定为explicit。作用：防止在需要隐式转换的上下文中使用构造函数。

friend成员：非类成员可以访问类的私有成员。需要特别注意友元声明和作用域。如果想将（其他类的）成员函数设为友元，必须先声明；而如果想将（其他）类或非成员函数设为友元，则不必预先声明。

static数据成员：static数据成员不用构造函数，在类的外部定义，定义时进行初始化。

static成员函数：声明时指定static类型，定义时不用重复声明。没有this指针。

const static数据成员：一般地类的static数据成员不能在类的内部定义。有例外就是可以用常量表达式初始化const static数据成员，不过即使这样也需要在类定义体的外部进行该const static数据成员的定义。

static成员不是类对象的组成部分，非static数据成员不能是该成员所属的类类型，而只能是对应的指针和引用，而static成员则可以是该成员所属的类类型。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!252.entry

queue             priority_queue         stack

队列                堆                         栈

deque             vector                   deque //默认相关联容器类型

push_front       随机访问                 无  //对关联容器的要求

1.插入：一般插入是在给定的迭代器位置前，这样是end迭代器也课正常编译。插入的元素类型必须与c的类型完全一样。

   void c.push_back(t);

    void c.insert(p,b,e);

    void c.insert(p,n,t);

    iter c.insert(p,t);

2.赋值：c1= c2

     c.assign(b,e); c.assign(n,t)  //允许不同的容器，不同的元素，只要元素类型兼容。

3.访问：c.back(); c.front();

c[n]; c.at[n]; //这样的下标访问容易越界。后者越界是抛出 out_of_range异常。

4.删除：iter c.erase(p);

iter c.erase(b,e);

void c.clear();

void c.pop_back();

c.pop_front();

file1.cpp   type v1;

        const type v2;  //now,v2 is a local variable.

        extern const type v3;//now,v3 is a global variable. must add 'extern'~.

file2.cpp   type v1; //  error.redeclaration.

        extern type v1; //ok.

        type v2; //ok.but not equivalent to v2 in file1.cpp

        const type v3;  // ok.but not equivalent to v3 in file1.cpp

        extern const type v3; //ok.equal to v3 in file1.cpp. 

2. const引用：const type& v; 是指向const对象的引用。非const引用只能绑定到与该引用同类型的对象。而const引用则可以绑定到不同但相关的类型那个的对象和右值。

double dv = 1.0;  const int &iv = dv; 编译时等价于

int temp = dv;  const int &iv = temp; //可以看出对iv的修改并不会影响dv的值

3.const与指针：（1） 指向const对象的指针: const type* v; 有时记作type const* v;可以修改指针，但不能直接通过该指针修改指针指向的对象。（可以通过定义非const指针指向该对象，从而修改其值）（2）const指针: type *const v;可以修改指针指向的对象，但不能修改指针本身。（3）指向const对象的const指针：const type *const v; （备注：typedef string * name;  const name v; //v的类型是指向string类型的const指针。） 

4.const与一般函数： (1) const type1 func(type2 v); 函数返回值为const; (2) type1 func(const type2 v);形参为const变量。因为形参不是引用，不修改实参的值，所以此时的const不起特别的作用；（3）type1 func(const type& v); 形参为const引用，不修改传递到形参的实参值。 指针时相同，不修改指针指向的对象的值。

5.const与类成员函数（常量成员函数）：type func(type v) const;等价于type func(const *this,type v) const; 它是值this指针是指向const对象的指针，这个函数不改变调用该函数的对象。（备注：事实上是不可以显示使用this指针作为形参的，但可以在函数体中显示地使用this指针。）

6.const与迭代器：vector<type>::const_iterator it;  const vector<type>::iterator iter; it指向的元素不能修改，iter指向的元素可以修改，但迭代器本身不能修改。

7.const与容器： const vector<type> vec; 需要注意此时定义的容器迭代器必须是const_iterator型。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!243.entry

2.引用形参是实参的别名，从而对形参的操作改变实参值。用途：第一，大型的参数通过复制初始化效率低时用引用参数；第二，对于一些不能复制初始化的参数；第三，可以通过增加形参返回额外的信息。 注意：type function(type2 v) 和 type function(const type2 v)是不同的。

3.const& :一般不需要修改实参时用const引用。这主要是考虑到非const引用形参的如下缺点：第一，传递的实参必须与形参类型完全相同，而不包含可以隐式转换的类型；第二，传递的实参不能是const，右值。

4.指向指针的引用 type* &v；

5.（1)非引用数组形参：int*, int[],int[n]。这三个是等价的，都传递指向第一个元素的指针。这样容易产生越界。如何防止越界呢？第一，通过结束标记检测数组的结束，如C风格字符串；第二，用标准库规范，传递第一个和最后一个的下一个元素的指针做参数；第三，显示传递数组大小的形参。

5.（2）引用数组形参：type (&arr)[n]； 注意两点：一是，圆括号是必须的，因为下标运算符的优先级更高；二是，表示数组元素个数的n是必须的，因为引用是数组别名，而数组是固定长度的。

6.默认实参：第一要考虑位置，第二，如果提供实参，则它覆盖默认的实参值。
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!242.entry

string str1("Hello!"); //ok.

char *str2 = str1; //error.

char *str3 = str2.c_str(); //ok. but not quite.

//注意c_str()返回的数据类型是const char

const char *str4 = str2.c_str(); //ok.
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!232.entry

可以采用 new type[]() 由内置类型的默认值初始化，注意不能在圆括号内写入值初始化。

但是当是单个对象定义时可以： new type(value) 是有效的
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!231.entry