久久国产热精品波多野结衣AV ,奇米综合四色77777久久,日韩人妻无码一区二区三区久久

内存��理

Sat, 05 Jun 2010 01:34:00 GMT

扩展阅读

内存的三�U�分配方式：

1�Q?nbsp;从静态存储区分配�Q�此时的内存在程序编译的时候已�l�分配好�Q��ƈ且在�E�序的整个运行期间都存在。全局变量�Q�static变量�{�在此存储�?/p>

2�Q?nbsp;在栈区分配：相关代码执行时创建，执行�l�束时被自动释放。局部变量在此存储。栈内存分配�q�算内置于处理器的指令集中，效率高，但容量有限�?/p>

3�Q?nbsp;在堆区分配：动态分配内存。用new/malloc时开辟，delete/free旉��放。生存期��q��h��定，灉|��。但有内存泄露等问题�?/p>

常见内存错误及对�{?/p>

1�Q?nbsp;内存分配未成功，却被使用�?/p>

对策�Q��用内存之前检查是否分配成功。用p!=NULL判断�?/p>

2�Q?nbsp;内存分配成功�Q�未初始化就被��用�?/p>

内存的缺省值没有统一的标准。大部分�~�译器以0作�ؓ初始��|��但不完全是�?/p>

对策�Q�内存初始化时赋初倹{�?/p>

3�Q?nbsp;内存操作��界�?/p>

对策�Q�只能是��心了�?/p>

4�Q?nbsp;释放了内存，仍然使用�?/p>

�Q?�Q?nbsp; 使用昄��delete和free的野指针�?/p>

对策�Q�释攑֮�内存�Q�将指针�|��ؓNULL�?/p>

�Q?�Q?nbsp; 使用隐式delete和free的野指针。主要是指函数返回指向栈内存的指针或引用�?/p>

对策�Q�当然是不要�q�回��可以了�?/p>

5�Q?nbsp;未释攑ֆ�存，��D��内存泄露�?/p>

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

对策�Q�new和delete的个��C��定相同；malloc和free的个��C��定相同；new[]和[]delete一定对应�?br>

�C�Z��1�Q�返回指向栈�I�间的指�?br>

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.试图修改常字�W�串
29         //str = NULL; //error.试图修改常字�W�串
30
31    str = test3();
32    cout << str << endl;
33}
34

输出�l�果�Q?br>��q��

Hello World!

Hello World!

�C�Z��2�Q?/span>new�?/span>delete虽然对应�Q�但delete释放不成�?/span>

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

    p = "ppp";

    delete []p;
}

�q�行旉��误�?/span>P虽然是动态开辟的内存�Q�但在第二条语句�?/span>p已经指向了静态存储区上的地址�Q�而对指向静态存储区的指针是不能�?/span>delete释放的。此时不仅运行时错误�Q�还有内存泄霌Ӏ?/span>

�q�运�?/a> 2010-06-05 09:34 发表评论

sscanf

Sun, 25 Apr 2010 12:13:00 GMT

int sscanf(const char* str, const char* format, ...)
functions: Reads data from str and stores them according to the parameter format into the locations given by the additional arguments. Locations pointed by each additional argument are filled with their corresponding type of value specified in the format string.

In the format:
Whitespace character: the function will read and ignore any whitespace characters which are encounterd before the next non-whitespace character.
Non-whitespace character: except percentage signs(%): any character that is not either a whitespace character or part of a format specifier causes the function to read the next character from str, compare it to this non-whitespace character and if it matches, it is discarded and the function continues with the next character of format and str. If the character does not match, the function fails and returns.
Return Value:
On success. the function returns the number of items successfully read.
On failure: In the case of an input failure before any data could be successfully read, EOF is returnded.

   //默认以空格分隔str��Z��同字�W�串,�q�回正确输入的变量个�?nbsp;
   char buf1[512] = {0};
   cout  << sscanf("abc def gh","%s",buf1) <<endl;   //1
   cout << buf1 << endl; //abc

   //可以使多个一起存�?nbsp;
   char buf2[512] = {0};
   char buf3[512] = {0};
   cout << sscanf("abc 2def gh","%s%s",buf2,buf3) <<endl;  //2
   cout << buf2 << endl; //abc
   cout << buf3 << endl;//2def

   //�I�格或format格式以外的字�W�如果匹配则与前一个字�W�串一赯��入，否则停止�Q�退�?nbsp;
   char buf4[512] = {0};
   char buf5[512] = {0};
   cout << sscanf("abc 2def gh","%s,%s",buf4,buf5) <<endl; //1
   cout << buf4 << endl; //abc
   cout << buf5 << endl; //nothing

   char buf6[512] = {0};
   char buf7[512] = {0};
   //注意两个%s之间的空��g��可少
   sscanf("abc 2def gh","%s 2%s",buf6,buf7);
   cout << buf6 << endl; //abc
   cout << buf7 << endl; //def

   //当然不只是字�W�串形式的，其他也都可以
   char buf8[512] = {0};
   int a;
   cout << sscanf("abc 2def gh","%*s %d",&a) <<endl;//1
   cout << a << endl;//2

   //Failure
   int b;
   cout << sscanf("abc","%d",&b) <<endl; //0

�q�运�?/a> 2010-04-25 20:13 发表评论

sprintf

Sun, 25 Apr 2010 11:23:00 GMT

sprintf: http://www.cplusplus.com/reference/clibrary/cstdio/sprintf/

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++不能�q�行�Q�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;

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

�q�运�?/a> 2010-04-25 19:23 发表评论

Mon, 19 Apr 2010 00:49:00 GMT

与复制构造函数和复制操作�W�不同，�~�译器��L��提供合成析构函数�?br>
合成析构函数做什么？
按对象创建时的逆序撤销每个非static成员�Q�包括指针成员�?br>只不�q�不删除指针成员所指向的对象�?/span>

�q�运�?/a> 2010-04-19 08:49 发表评论

Sun, 18 Apr 2010 11:59:00 GMT

当在�cȝ��构造函��C��中申请了资源(如内存空�?�Q�需要在对象被销毁时�q�行释放时�?

class Test
{
public:
    Test(const char* ptr)
    {
        if(ptr)
        {
            p = new char[strlen(ptr)];
        }
    }
    ~Test()
    {
        delete[] p;
    }
private:
    char* p;

};

�q�运�?/a> 2010-04-18 19:59 发表评论

指针学习2--内存泄露

Sun, 18 Apr 2010 04:06:00 GMT

内存泄露的情�?br>�Q?

1#include <iostream>
2using namespace std;
3
4class Stu
5{
6   public:
7         Stu(int m):var(m)
8         {
9                  cout << var <<" constructor called." << endl;
10         }
11          ~Stu() { cout << var << " destructor called." << endl;}
12   private:
13          int var;
14};
15
16
17int main()
18{
19    Stu *a = new Stu(20);
20    Stu *b = new Stu(30);
21    delete b;
22    return 0;
23    //or 其他隐藏异常
24
25    //��D��内存泄露
26    delete a;
27
28    return 0;
29}

�q�运�?/a> 2010-04-18 12:06 发表评论

指针学习1--new &delete & destructor

Sun, 18 Apr 2010 02:58:00 GMT

1. 一般指针的new&delete

对于指针a,delete a之后�Q�指�?/span>a 的地址仍然是原来的地址(�q�不是NULL)�Q�只不过所指向的对象被释放了，此时指针存放的��gؓ随机的，��q��译器��定�?br>

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;

常规�Ҏ(gu��)��创徏的对象，当实际对象（而不是对象的引用�Q�超��Z��用域�Ӟ��才会�q�行析构函数
动态方法创建的对象�Q�当删除指向动态分配对象的指针�Ӟ��才会�q�行析构函数�?nbsp;

2. 一般类对象的声明与初始化：不用new也可以定义类对象�Q�区别于java�Q�，默认调析构函�?br>注：为方便简单演�C�，�q�没有遵循三法则

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       //调用构造函�?/span>
17       Stu a(20);
18       //调用默认复制构造函�?/span>
19       Stu b(a);
20       //�{��h(hu��n)于Stu temp(b); Stu b(temp);
21       //所以有调用构造函数的�q�程
22       Stu c = 30;
23       //都是用隐式方式定义的�Q�所以不用delete,自动调用析构函数
24 |        //注意析构的顺�?nbsp;
25}
26
27int main()
28{
29   func();
30   return 0;
31}

�q�里有一个需要注意的地方�Q�就是如果func里面的代码是直接写在main里的则不一定调用析构函�?nbsp;�Q�由�~�译器决定�?br>上面是dev c++, 下面是vc6.0的运行结�?br>

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

3. 用new定义�c�d��?必须delete
动态分配的对象只有在指向该对象的指针被删除时才撤销。如果没有删除指向动态对象的指针�Q�则不会�q�行该对象的析构函数�Q�对象则一直存在，从而导致内存泄霌Ӏ?br>常规�Ҏ(gu��)��创徏的对象，当实际对象（而不是对象的引用�Q�超��Z��用域�Ӟ��才会�q�行析构函数
动态方法创建的对象�Q�当删除指向动态分配对象的指针�Ӟ��才会�q�行析构函数�?br>

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       //调用构造函�?/span>
17       Stu* a = new Stu(20);
18       //调用默认复制构造函�?/span>
19       Stu* b= new Stu(*a);
20       //�{��h(hu��n)于Stu temp = new Stu(30); Stu b(temp);
21       //所以有调用构造函数的�q�程
22       Stu c = 30;
23       //new出来的指针对象，必须昄��delete,如a,b
24       //�c�d��象结束局部范围后会自动调用析构函�?nbsp;如c
25       delete a;
26       delete b;
27}
28
29int main()
30{
31   func();
32   return 0;
33}

�q�运�?/a> 2010-04-18 10:58 发表评论

宏与内联(inline)的区�?转蝲)

Thu, 04 Mar 2010 12:22:00 GMT

先�{载下人家�ȝ��的宏和普通函数调用的区别�Q?br>(1)、宏只做��单的字符串替换，函数是参��C��递，所以必然有参数�c�d��?支持各种�c�d��Q�而不是只有字�W�串)�?br>(2)、宏不经计算而直接替换参敎ͼ�函数调用则是��参数表辑ּ�求值再传递给形参�?br>(3)、宏在编译前�q�行�Q�即先替换再�~�译。而函数是�~�译后，在执行时才调用的。宏占编译时��_��而函数占执行旉��?br>(4)、宏参数不占�I�间�Q�因为只做字�W�串替换�Q�而函数调用时参数传递是变量之间的传递，形参作�ؓ局部变量占内存�I�间�?br>(5)、函数调用需要保留现场，然后转入调用函数执行�Q�执行完毕再�q�回主调函数�Q�这些耗费在宏中是没有的�?/p>

使用宏和内联函数都可以节省在函数调用斚w��的时间和�I�间开销。二者都是�ؓ了提高效率，但是却有着显著的区别：
(1)、在使用�Ӟ��宏只做简单的预处理器�W�号�?字符�?中的��单替换。而内联函数可以进行参数类型检查，且具有返回�?也能被强制�{换�ؓ可�{换的合适类�?�?br>(2)、内联函数首先是函数�Q�函数的许多性质都适用于内联函�?如内联函数可以重�?�?br>(3)、内联函数可以作为某个类的成员函敎ͼ��q�样可以使用�cȝ��保护成员和私有成员。而当一个表辑ּ�涉及到类保护成员或私有成员时�Q�宏��׃��能实��C��(无法��this指针攑֜�合适位�|?�?/p>

可以用内联函数完全替代宏�?br>但是在��用内联函数时也要注意�Q�作为内联函敎ͼ�函数体必��d��分简单，不能包含循环�Q�条�Ӟ��选择�{�复杂结构，否则不能作�ؓ内联函数�?br>实际上，�~�译器的优化�pȝ��会自动将一些简单函数变成内联函数。而一些复杂的函数�Q�即使指定�ؓ内联�Q�编译器也会自动当作普通函数�?/p>

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

�q�运�?/a> 2010-03-04 20:22 发表评论

随机数的生成

Thu, 21 Jan 2010 07:37:00 GMT

rand() 可获得伪随机数。但是仅仅这样写的话�Q�同一�D�代码每�ơ运行程序获得的随机数相同�?br>
因�ؓ在调用rand()前自动调用了srand(1); �q�条语句�?只有当srand()的�Ş参是变化的时每次�q�行获得的随机数才不同�?br>
用什么样的随时变化的参数呢？用time(NULL), 即srand((unsigned)time(NULL)); rand(); �q�样每次�q�行得到的随机数不同�?br>
如何获得某个区间的随机数�Q?br>      ---- 如果是区间[0,n),   rand()%n ��可以了
      ---- 如果是区间[m,n), rand()%n+m ��可以了
     ----如果是区[0,1), rand()/double(RAND_MAX) ��可以可以了�?RAND_MAX在cstdlib里有定义)

�q�里有更详细的介�l�：
http://blog.csdn.net/zhoubl668/archive/2009/01/04/3704604.aspx

�q�运�?/a> 2010-01-21 15:37 发表评论

Fri, 08 Jan 2010 08:30:00 GMT

摘要:
�?对于父类函数�Q�virtual、非virtual�Q�，如果子类没有同名函数�Q�则正常�l�承

�?对于父类函数�Q�virtual、非virtual�Q�，如果子类有同名函敎ͼ�无同型函敎ͼ�则不能调用父�c�d��?

�?对于父类函数�Q�virtual、非virtual�Q�，如果有同型函敎ͼ�

----非virtual函数由指针类型决定调用哪�?

----virtual函数由指针指向的对象军_��调用哪个�Q�运行时军_��Q?
阅读全文

�q�运�?/a> 2010-01-08 16:30 发表评论

�c�static成员

Fri, 08 Jan 2010 04:22:00 GMT

�c?/span>static成员引进�Q�有时特定类的全体对象需要访问一个全局对象�?/span>

�?/span>��Z��么用static成员而不是全局对象�Q?/span>

---- static对象名字在类作用域中�Q�可以有效避免命名冲�H�，�q�且清晰昄��E�序意图�?/span>

---- 可以实施��装�Q?/span>static成员可以定义�?/span>private�Q�而全局对象不可以）

�?/span> 如何调用�Q?/span> ---- class A a; A::static_mem; a.static_mem;

�?/span> 声明和定�?/span>

---- static成员函数在类定义体内部外部定义均可。在�c�d��义体外定义时不加�Q�不可以加）static修饰�?/span>

---- static数据成员必须在类定义体外部定义（正好一�ơ）(在类定义体外声明�q�定�?/span>)

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

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

�?/span> static数据成员其他�Ҏ(gu��)��：

----一般地�Q�在�cȝ��内部不能有该�cȝ��型的变量�Q�或函数形参�Q�，最多只能有该类�c�d��的指针或引用做变量类型（或函数�Ş参）. static数据成员则不受这个限制�?/span>

---- �cȝ��static数据成员可以作�ؓ函数默认实参

---- static成员的��承：如果基类有static成员�Q�则整个�l�承层次中只有一个这��L��成员。每个static成员��L��只有一个实例�?br>

1#include <iostream>
2#include <cstdlib>
3
4using namespace std;
5
6class A
7{
8      //重蝲输出操作�W?nbsp;
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; //�c�d��以有该类�c�d��的static成员
24       //A a1; //error. �c�M��可以有普通的该类�c�d��的成�?nbsp;
25
26       static void func(A a) {cout << a << endl;} //�cȝ��型可以作��c�static函数的�Ş�?nbsp;
27
28       //static 数据成员可以作�ؓ�c�L��员函数的默认实参
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}

�q�运�?/a> 2010-01-08 12:22 发表评论

深入理解strcpy�Q�strncpy

Sun, 26 Apr 2009 12:59:00 GMT

摘要: 用strcpy和strncpy时的一些疑问答疑，含两个函数的源代码�?nbsp; 阅读全文

�q�运�?/a> 2009-04-26 20:59 发表评论

sizeof�Q�（含位域）�l�构体内存对齐，压羃存储

Sat, 25 Apr 2009 03:33:00 GMT

摘要: 较全面分析sizeof�Q?
1. 一些基本类型的vc6 sizeof�l�果
2. �l�构体的内存寚w��
3. 含位域的�l�构体介�l?
4. 含位域的�l�构体的内存寚w��Q�压�~�存储和非压�~�存储）
5. 嵌套�l�构体的sizeof
6. �c�d��象的sizeof
7. 通过代码如何修改默认寚w��模数阅读全文

�q�运�?/a> 2009-04-25 11:33 发表评论

[导入]多重�l�承与虚�l�承

Wed, 25 Mar 2009 08:20:00 GMT

Technorati 标签: 多重�l�承�Q�虚�l�承

1.多重�l�承下的�c�M��用域名字查找规则�Q?/strong>�W�一步，�~�译器找��C��个匹配的声明。如果匹配的声明不止一个，则导致二义性，出错�Q�第二步�Q�编译器��定扑ֈ�的名字是否合法�?

避免二义性的�Ҏ(gu��)��Q�在解决二义性的�z��c�M��定义函数的一个版本�?

2. 采用虚��承的�Ҏ(gu��)��可以有效减少二义性�?/strong>定义虚��承的�Ҏ(gu��)��Q�在�z��列表中包�?#8220;virtual”�?

虚��承中名字查找�Ҏ(gu��)��。设查找函数func�Q�（1�Q�如果在每个路径中func表示同一基类成员�Q�则没有二义性，因�ؓ�c�d��享该成员的单个实例。（2�Q�如果在某个路径中func是虚基类的成员，而在另一路径上是后代�z��cȝ��成员�Q�也没有二义性，因�ؓ特定�z��c�d��例的优先�U�高于共享虚基类实例。（3�Q�如果沿每个�l�承路径func表示后代�z��cȝ��不同成员�Q�则��h��二义性�?

3.虚��承的�Ҏ(gu��)��初始化方�?/strong>。通常�Q�每个类只初始化自己的直接基�c�R��但在虚�l�承中也�q�样�q�行的话�Q�可能会多次初始化虚基类�?

由最低层�Q�非虚��承）�z��cȝ��构造函数初始化虚基�c�R��（2�Q��Q何直接或间接�l�承虚基�cȝ��c�M��般也必须��虚基�c�L��供自��q��初始化式�Q�以提供自��n对象初始化��用�?

class ZooAnimal{...};

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

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

class Endangered{...};

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

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

4. 虚��承的构造函数次�?/strong>。先是全部直接基�cȝ��虚基�cȝ��构造函数按声明的顺序，然后是非虚基�c�d��数按声明的顺序运行�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9a%e5%a4%9a%e9%87%8d%e7%bb%a7%e6%89%bf%e4%b8%8e%e8%99%9a%e7%bb%a7%e6%89%bf&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!267.entry

�q�运�?/a> 2009-03-25 16:20 发表评论

Wed, 25 Mar 2009 06:56:00 GMT

1. 模板定义内的自定义类型成员调用方法（用typename昄��说明�Q�：�c�d��以定义类型成员，如size_type, size_t�{�类型。在定义模板�c�L��如何调用它呢�Q��ؓ了说明是�c�d��Q�显�C�用typename说明�?
template
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. 非类型模板�Ş参的使用: 模板非类型�Ş参是模板定义内部的常量�?(在需要常量表辑ּ�的时�?可以用非�c�d��形参,如定义数�l�的长度)�?
因�ؓ非类型模板�Ş参需要传递的是常量表辑ּ��Q�所以不支持一般的隐式�c�d��转换�?
template void fcn(T (&cl)[N]) {...}
int x[20];
fcn(x);

3. 模板何时实例化？函数声明�Q�定义对象的引用和指向对象的指针都不会实例化。定义类对象或调用函数时实例化�?
4.friend模板声明依赖性：�Q?�Q?当授予对�l�定模板所有实例的讉K��权时�Q�在作用域中不需要存在该�c�L��板或函数模板的声明。编译器��友元声明也当作�c�L��函数的声明对待；�Q?�Q�想要限制对特定实例化的友元关系�Ӟ��必须在可以用于友元声明之前声明类或函数�?
5.对于不同参数的函数模板用相同参数可以调用么？可以�Q�会调用隐式转换�?
#include
using namespace std;
template
void print(const T1 &v1, const T2 &v2) //参数�c�d��不同
{
    cout << "T1 = " << v1 <    cout << "T2 = " << v2 <}
int main()
{
    print(1,2); //ok
    int a=1;
    int b=2;
    print(a,b); //ok�Q��Ş参类型相�?/font>
    return 0;
}
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!266.entry

�q�运�?/a> 2009-03-25 14:56 发表评论

[导入]模板�~�译模型

Tue, 24 Mar 2009 07:50:00 GMT

1.包含�~�译模型�Q�inclusion compilation model�Q? 函数声明攑֜�头文件中�Q�定义放在源文�g中。头文�g��֌�含源文�g。据说会出现一个模板实例化多次从而导致编译时性能显著降低�?
//template.cpp
template
void print(const T &v)
{
    cout << "T = " << v <}
//template.h
#ifndef TEMPLATE_H
#define TEMPLATE_H
template
void print(const T &v);
#include "template.cpp"
#endif
//main.cpp
#include
#include "template.h"   //#include"template.cpp" 用这条命令代替也可以�?/font>
using namespace std;
int main()
{
    print(1); //ok
    return 0;
}
2. 分别�~�译模型�Q�seperate compilation model�Q?函数声明和类定义攑֜�头文件中�Q�带export关键字的函数定义和类声明攑֜�源文件中。源文�g��֌�含头文�g。（不知道理解的对不对，用的�~�译器不支持分别�~�译�Q�暂时无从判断了�Q?
//the template definition goes in a separately-compiled source file
export template
T print(const T&v) /*...*/
//class template header goes in shared header file
template class cl{...};
//cl.cpp implementation file declares cl as exported
export template class cl;
#include "cl.h"
//cl member definitions

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

�q�运�?/a> 2009-03-24 15:50 发表评论

Mon, 23 Mar 2009 11:09:00 GMT

构造函��C��能定义�ؓvirtual�Q�派生类对象的基�c�L��据成员部分在初始化列表中用基�c�L��造函数初始化�Q?
基类析构函数应定义�ؓvirtual�Q�复制操作符一般定义�ؓ非virtual
在基�c�L��造函数和析构函数中，��派生类对象当作基类�c�d��对象对待。（因�ؓ在这两个函数的运行过�E�中�Q�对象不是一个完整的�z��cȝ��型）
�cȝ��复制控制的三法则有个例外�Q�定义（�I�）虚构够函数时可以不定义构造函数和赋值函数�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9a%e5%9f%ba%e7%b1%bb%e7%9a%84%e5%a4%8d%e5%88%b6%e6%8e%a7%e5%88%b6%e5%87%bd%e6%95%b0&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!264.entry

�q�运�?/a> 2009-03-23 19:09 发表评论

Sun, 22 Mar 2009 12:22:00 GMT

�z��c�L��w�的成员和友元�Q何��承时都可以��用派生类到基�c��{换�?
对于后代�c�d��用户代码�Q?
public�l�承�Ӟ��后代�c�d��用户代码都可以�?
protected�l�承�Ӟ��后代�c�d��以，用户代码不可以�?
private�l�承�Ӟ��后代�c�d��用户代码都不可以�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9a%e6%b4%be%e7%94%9f%e7%b1%bb%e5%88%b0%e5%9f%ba%e7%b1%bb%e8%bd%ac%e6%8d%a2%e7%9a%84%e5%8f%af%e8%ae%bf%e9%97%ae%e6%80%a7&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!263.entry

�q�运�?/a> 2009-03-22 20:22 发表评论

Sun, 22 Mar 2009 11:26:00 GMT

1.�z��c�d��基类private成员没有讉K��权限�?
2.�z��c�d��能通过�z��c�d��象访问其基类的protected成员�Q�派生类对其基类�c�d��对象的protected成员没有�Ҏ(gu��)��讉K��权限�?
#include
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

�q�运�?/a> 2009-03-22 19:26 发表评论

[导入]析构函数�Q�内存泄漏，三法则）

Sun, 08 Mar 2009 13:25:00 GMT

Technorati 标签: 析构函数�Q�内存泄漏，三法�?/a>

��M��时候编译器都会合成析构函数�Q��ƈ且合成的析构函数��M��q�行�?
撤销容器�Q�标准库容器和内�|�数�l�）是按逆序�q�行的�?
内存泄漏�Q�Memory leak�Q�：删除指向动态分配内存的指针��p�|�Q�因而无法将该块内存�q�还�l�自由存储区�Q�这��L��删除动态分配内存失败称为内存泄漏�?/font>
只有当删除指向类对象的指针时才会�q�行该对象的析构函数。如果不删除指针�Q�则对象一直存在，��D��内存泄漏�?
三法则（rule of three�Q�：如果�c�需要析构函敎ͼ�则也需要赋值操作符和复制构造函数�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9a%e6%9e%90%e6%9e%84%e5%87%bd%e6%95%b0%ef%bc%88%e5%86%85%e5%ad%98%e6%b3%84%e6%bc%8f%ef%bc%8c%e4%b8%89%e6%b3%95%e5%88%99%ef%bc%89&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!255.entry

�q�运�?/a> 2009-03-08 21:25 发表评论

Sun, 08 Mar 2009 13:00:00 GMT

Technorati 标签: �c�d��始化列表�Q�默认构造函敎ͼ�复制构造函�?/a>

初始化列表：通常使用初始化是��Z��提高效率�Q�它直接调用与实参匹配的构造函数。【因��Z��般在构造函��C��内的复制也经�q�初始化-->计算赋�?font color=#404040>�Q�此时会调用复制构造函敎ͼ�两个阶段】；特别的有些时候只能用初始化列表，即不能赋值的参数�Q�如�Q�const或引用类型的成员�Q�没有默认构造函数的�cȝ��型成员。初始化列表中变量的初始化顺序是先声明的先初始化.
class cl1{ private: const int ci; int &ri;}; //ci,ri只能在初始化列表中进行初始化�?/font>
默认构造函敎ͼ�全部形参是默认实参的构造函��C��是默认构造函数�?/font>
只要自己定义了（��L��的）构造函敎ͼ��~�译器就不会为我们合成默认构造函数�?
复制构造函敎ͼ�单个形参为本�cȝ��型对象的引用的构造函数。对于不支持复制的类型（如IO�c�d��Q�不能用复制构造函数。如果自己定义了复制构造函敎ͼ�而不是构造函敎ͼ�卻I��只定义构造函敎ͼ�但没有定义复制构造函敎ͼ�则编译器合成复制构造函敎ͼ��Q�则�~�译器不会合成复制构造函数。【复制构造函数需要特别注意指针成员，以后��说明�?/font>
ifstream file1("filename1"); //ok, direct initialization.
ifstream file2="filename2"; //error
如何防止复制�Q?/font>可以通过��复制构造函数声明�ؓprivate来禁止普通函敎ͼ�非成员，非友元函敎ͼ�的访问；可以通过声明一个private复制构造函数而不对其定义来禁止成员函数和友元函数的访问�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9a%ef%bc%88%e5%a4%8d%e5%88%b6%e3%80%81%e9%bb%98%e8%ae%a4%ef%bc%89%e6%9e%84%e9%80%a0%e5%87%bd%e6%95%b0&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!254.entry

�q�运�?/a> 2009-03-08 21:00 发表评论

Fri, 06 Mar 2009 13:57:00 GMT

inline成员函数�Q?/font> 声明或定义时指定为inline都可以。作用：在调用处直接在行内展开代码�Q�以提高效率。类的inline成员函数定义在包含该�cȝ��头文件中�?�c�d��部定义的函数均�ؓinline函数�?
mutable数据成员�Q��Q何函敎ͼ�包括�c�const成员函数�Q�都可以修改mutable数据成员�?
explicit构造函敎ͼ�声明时指定，定义时不允许重复指定为explicit。作用：防止在需要隐式�{换的上下文中使用构造函数�?
friend成员�Q?/font>非类成员可以讉K��cȝ��U�有成员。需要特别注意友元声明和作用域。如果想��（其他�cȝ��Q�成员函数设为友元，必须先声明；而如果想��（其他�Q�类或非成员函数设�ؓ友元�Q�则不必预先声明�?
static数据成员�Q?/font>static数据成员不用构造函敎ͼ�在类的外部定义，定义时进行初始化�?
static成员函数�Q?/font>声明时指定static�c�d��Q�定义时不用重复声明。没有this指针�?
const static数据成员�Q?/font>一般地�cȝ��static数据成员不能在类的内部定义。有例外��是可以用常量表辑ּ�初始化const static数据成员�Q�不�q�即使这样也需要在�c�d��义体的外部进行该const static数据成员的定义�?
static成员不是�c�d��象的�l�成部分�Q�非static数据成员不能是该成员所属的�cȝ��型，而只能是对应的指针和引用�Q�而static成员则可以是该成员所属的�cȝ��型�?/font>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!252.entry

�q�运�?/a> 2009-03-06 21:57 发表评论

Fri, 06 Mar 2009 11:17:00 GMT

queue             priority_queue         stack
队列                �?nbsp;                        �?
deque             vector                   deque //默认相关联容器类�?/font>
push_front       随机讉K��                 �?nbsp; //对关联容器的要求

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

�q�运�?/a> 2009-03-06 19:17 发表评论

Fri, 06 Mar 2009 11:11:00 GMT

感觉�q�代器这部分函数的返回类型是没太弄明白的�Q�以后用的时候得多注意点�?
1.插入�Q?/font>一般插入是在给定的�q�代器位�|�前�Q�这��h��end�q�代器也课正常编译。插入的元素�c�d��必须与c的类型完全一栗��?
   void c.push_back(t);
    void c.insert(p,b,e);
    void c.insert(p,n,t);
    iter c.insert(p,t);
2.赋�?/font>�Q?font color=#ff00ff>c1= c2
     c.assign(b,e); c.assign(n,t) //允许不同的容器，不同的元素，只要元素�c�d��兼容�?/font>
3.讉K��Q?/font>c.back(); c.front();

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

4.删除�Q?font color=#ff00ff>iter c.erase(p);

iter c.erase(b,e);
void c.clear();
void c.pop_back();
c.pop_front();

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

�q�运�?/a> 2009-03-06 19:11 发表评论

Sat, 28 Feb 2009 13:38:00 GMT

1. const变量�Q?/font>const type v; 必须定义时初始化�Q�不能修改其倹{�?font color=#404040>备注�Q�关于const变量的作用域要特别注意，它是局部的�Q�而默认的C++变量是全局的。通过加extern限制可以令const对象可以在全局被访问。如代码�Q?��Z��提一下static)
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引用�Q?/font>const type& v; 是指向const对象的引用。非const引用只能�l�定��C��该引用同�c�d��的对象。而const引用则可以绑定到不同但相关的�c�d��那个的对象和叛_��{�?
double dv = 1.0; const int &iv = dv; �~�译时等价于
int temp = dv; const int &iv = temp; //可以看出对iv的修改�ƈ不会影响dv的�?
3.const与指�?/font>�Q�（1�Q?指向const对象的指�? const type* v; 有时��C��type const* v;可以修改指针�Q�但不能直接通过该指针修�Ҏ(gu��)��针指向的对象。（可以通过定义非const指针指向该对象，从而修改其��|��Q?�Q?font color=#ff0000>const指针: type *const v;可以修改指针指向的对象，但不能修�Ҏ(gu��)��针本�w�。（3�Q?font color=#ff0000>指向const对象的const指针�Q?font color=#ff00ff>const type *const v; �Q?font color=#404040>备注�Q?font color=#ff00ff>typedef string * name; const name v; //v的类型是指向string�c�d��的const指针。）
4.const与一般函敎ͼ� (1) const type1 func(type2 v); 函数�q�回��gؓconst; (2) type1 func(const type2 v);形参为const变量。因为�Ş参不是引用，不修改实参的��|��所以此时的const不�v特别的作用；�Q?�Q?font color=#ff00ff>type1 func(const type& v); 形参为const引用�Q�不修改传递到形参的实参倹{�?指针时相同，不修�Ҏ(gu��)��针指向的对象的倹{�?
5.const与类成员函数�Q�常量成员函敎ͼ��Q�type func(type v) const;�{��h(hu��n)于type func(const *this,type v) const; 它是值this指针是指向const对象的指针，�q�个函数不改变调用该函数的对�?font color=#404040>。（备注�Q�事实上是不可以昄��使用this指针作�ؓ形参的，但可以在函数体中昄��C��用this指针。）
6.const与�P代器�Q?/font>vector::const_iterator it; const vector::iterator iter; it指向的元素不能修改，iter指向的元素可以修改，但�P代器本��n不能修改�?
7.const与容器： const vector vec; 需要注意此时定义的容器�q�代器必��L��const_iterator型�?img height=1 alt="" src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=982263437555584821&page=RSS%ef%bc%9aconst%e9%99%90%e5%88%b6%e7%ac%a6&referrer=" width=1 border=0>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!243.entry

�q�运�?/a> 2009-02-28 21:38 发表评论

[导入]函数参数

Sat, 28 Feb 2009 11:18:00 GMT

1.非引用�Ş�?/font>通过复制实参值创建和定义函数的局部对象，从而对形参的操作不改变实参倹{��因为是复制初始化在形参前加const无媄响�?font color=#ff00ff>type function(type2 v) �?font color=#ff00ff>type function(const type2 v)是等��L��。这一点在函数重蝲时也要注意，如果同时出现上述的两个函数则是重复定义而不是重载�?/font>
2.引用形参是实参的别名�Q�从而对形参的操作改变实参倹{��用途：�W�一�Q�大型的参数通过复制初始化效率低时用引用参数�Q�第二，对于一些不能复制初始化的参敎ͼ��W�三�Q�可以通过增加形参�q�回额外的信息�?注意�Q?/font>type function(type2 v) �?type function(const type2 v)是不同的�?/font>
3.const& :一般不需要修改实参时用const引用。这主要是考虑到非const引用形参的如下缺点：�W�一�Q�传递的实参必须与�Ş参类型完全相同，而不包含可以隐式转换的类型；�W�二�Q�传递的实参不能是const�Q�右倹{�?/font>
4.指向指针的引�?/font> type* &v�Q?/font>
5.�Q?)非引用数�l��Ş�?/font>�Q?font color=#ff00ff>int*, int[],int[n]�?/font>�q�三个是�{��h(hu��n)的，都传递指向第一个元素的指针。这样容易��生越界。如何防止越界呢�Q�第一�Q�通过�l�束标记��数�l�的�l�束�Q�如C风格字符�Ԍ��W�二�Q�用标准库规范，传递第一个和最后一个的下一个元素的指针做参敎ͼ��W�三�Q�显�C�Z��递数�l�大��的形参�?/font>
5.�Q?�Q?font color=#ff0000>引用数组形参�Q?font color=#ff00ff>type (&arr)[n]�Q?/font> 注意两点�Q�一是，圆括��h��必须的，因�ؓ下标�q�算�W�的优先�U�更高；二是�Q�表�C�数�l�元素个数的n是必��ȝ��Q�因为引用是数组别名�Q�而数�l�是固定长度的�?/font>
6.默认实参�Q�第一要考虑位置�Q�第二，如果提供实参�Q�则它覆盖默认的实参倹{�?/font>
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!242.entry

�q�运�?/a> 2009-02-28 19:18 发表评论

[导入]C风格字符串与string�c�d��

Fri, 27 Feb 2009 13:18:00 GMT

C风格字符串等价于string �c�d��字符串字面�?
string str1("Hello!"); //ok.
char *str2 = str1; //error.
char *str3 = str2.c_str(); //ok. but not quite.
//注意c_str()�q�回的数据类型是const char
const char *str4 = str2.c_str(); //ok.
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!232.entry

�q�运�?/a> 2009-02-27 21:18 发表评论

Fri, 27 Feb 2009 13:09:00 GMT

动态分配的数组�Q?/font>成员为类�c�d��时用默认构造函敎ͼ�为内�|�类型时不自动初始化。（同函数内部变量的自动初始化）
可以采用 new type[]() 由内�|�类型的默认值初始化�Q�注意不能在圆括号内写入值初始化�?
但是当是单个对象定义时可以： new type(value) 是有效的
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!231.entry

�q�运�?/a> 2009-02-27 21:09 发表评论