Linux内核编程必读（英文版）

本书是一本Linux内核编程的权威指南，其独特的由表及里学习途径使得内核编程更易于理解。本书从用户空间到内核，把内核内在的实现原理与用户级编程的基本原则相联系，系统地跟踪了实现功能。这种途径有助于在你所了解的Linux知识基础上，加深对内核组成及工作机理的理解。 为了理解内核代码并掌控其行为，作者逐步引入所有的工具和汇编语言编程技术，并一一比较x86和PowerPC的实现，揭示了含糊不清的实现功能。另外，书中对源代码例子和实际项目都加有适当注释。本书是第一本全面涵盖快速增长的PowerPC Linux开发平台的书，也是惟一一本用Linux构建系统彻底讨论内核配置的书。

成就；反而是�

第一天：面向对象程序的设计把数据封装在一个安全的外壳中，并使他们具有活动性，变量可以主动的对自己进行操作而非被动等待程序代码对它操作。当需要打印变量内容时你不需要进行打印它们，只需要告诉变量进行打印自己。 上面说的变量和面向对象中说的对象理论上没有什么区别，只是C++这种OPP语言使数据具有了行为。 在C++中对象通常是指用户自定义的数据类型的类变量或结构变量，用户可以通过向这种数据类型添加函数使这个变量具有行为。 第二天：在学习C++之前用来定义自己的数据类型大概有以下三种方法：结构：struct; 枚举：enum; 联合：union通常把它们称为集合数据类型。 当定义一个变量赋值后从未使过编译时会警告，但程序可以通过。 函数是构成C++程序的主要部分。将程序分解为一些独立的模块，这些模块就称为函数，函数可以使程序的结构模块化。 所有的函数都必须进行原型声明，函数原型声明可以放在头文件中。负责告诉编译器函数中将要使用的参数的个数和类型。格式如下： 函数类型 函数名（参数类型1 参数1[，参数类型2 参数2] [，......]）; 函数的第一行和函数原型声明一样，区别只是最后的没有分号。 函数的参数传递： 一种方法是用值传递，比较好理解，还有一种是传递实参的方法，及在引用调用函数方式时，将向函数传递参数的地址而不是参数的实际值。这样的好处是函数可以返回多个值。 函数原型防止程序输出时潜在的错误。 主函数不需要原型说明，因它被看作是一个自动说明原型的函数，主函数是第一个被执行的函数，且它不存在被别的函数调用的问题。 第三天：在使用IO流时需要头文件IOSTREAM，当时用流操纵算子和格式标志时需包含IOMANIP。 指针真正的作用是用指针在两个函数之间传递参数，和在堆中动态的分配内存。 void指针是全程指针，它可以指向任意的数据类型，除了const和volatile类型的指针外任何类型的指针变量都可以赋值给void类型的指针，甚至包括函数指针。 int i; //定义一个整形变量 int * ptrl; //定义一个指向整形的指针，也可以不严格的叫整型指针 i=10; ptrl=&i; //&是取地址运算符，本例是将整型变量i的地址置于ptrl变量中 注意，void类型的指针在引用时必须强制进行类型转换，而且把它们赋值给其他类型时也必须进行类型转换。反过来一个普通的类型指针可以直接赋值给void类型。在进行强制类型转换时必须把星号和类型转换用括号括起来。 iptr=(int *)vptr; 以上讨论同样适合两个函数之间的用不同类型的指针传递参数 第四天：引用是自动的能间接引用的一种指针。 　　自动间接引用的意思是可以自动得到一个引用值而不必使用间接引用操作符*。引用产生变量的另一个别名。引用的作用是通过引用在函数之间传递和返回参数。 int i=9; //定义一个整数变量i并把9赋值给它 int *iptr=&i; //定义一个整数指针变量iptr并将整数变量的地址赋值给它 int &rptr=i; //定义一个引用rptr并让它指向整数变量i，也就是rptr是i的一个别名，所有对rptr的操作都是对 file://rptr引用的变量i的操作。 如果要使用iptr所制的变量i，必须用*间接引用指针，而使用引用rptr所引用的变量i则什么都不用直接使用rptr就行。 用&定义一个引用； 象使用一个自用间接引用的指针一样使用引用； 为了简化多重指针的语法引用可以引用一个指针； 在定义一个引用时一定要初始化； 不要用*来间接引用一个引用； 一个引用只是依附在其所指变量的一个别名，这种依附在引用的作用范围内保持不变。 const int myage=18; file://指向常数的指针：定义一个指针指向一个常数（虽然指向的不一定是常数）。 const int * aptrage=&myage; file://常数指针：定义一个不能改变的指针，但它指向的值可以改变，同常数一样必须在定义常数指针的时候进行初始化。 int * const aptrage=&myage; file://指向常数的常数指针：前两者结合。 const int * const aptrage=&myage; 用const来保护不应改变的值； 不能通过指针改变一个常数； 常数指针不可改变； 不能改变一个指向常数的常数指针和它指向的常数。 只读引用（只读别名）：一个指向常数的引用； int iv=18; const int &rv=ic; //定义一个指向常数iv的引用，不允许通过rv改变iv因是只读引用。 练习： # include main(){ int monthdays[]={31,28,31,30,31,30,31,31,30,31,30,31}; int *const mpmonth=monthdays; for (int i=0; i<12; i++){ file://cout<<(mpmonth+i)< cout<<(i+1)<<"月有："<<*(mpmonth+i)<<"天"< } return 0; } 第五天：new和delete是内存分配操作符，new用于分配内存，delete用于释放内存。 堆是计算机中一大块未使用的内存（除去操作系统和正在使用的应用程序所占内存之外的剩余内存），它的大小是随时在改变的，所以是动态内存。 在用new分配内存时不必对返回指针做类型转换。分配单一变量如int、float没有意义，分配数组时只需一个指针指向它的多个元素。 char *eName=new char[9]; delete [] eName; //释放为eName分配的所有内存。 堆不会自己初始化，必须用自己的数据初始化。 应该在分配内存时进行初始化 char * eName=new char('a'); //这是一个字符。 char * eName=new char[9]; //这是一个数组，有九个元素（如果是字符串，还要包括NULL0的空间）。 strcpy(eName,"base wood"); //初始化数组的例子。 两维或两维以上的数组称为多维数组，也可叫矩阵（一维以上的数组，也称表）。 dataType (*matrixName)[numELs]....//矩阵变量的定义。 dataType//是任意的数据类型包括用户自定义的 matrixName//矩阵变量的名 numELs//除第一维后的维的大小。 例子： float (* table)[6]; //定义矩阵变量 table=new float[5][6]; //分配存放30个浮点数的内存给矩阵变量。 float * table[6]=new float[5][6]; //可以合并为： delete [] table; //全部释放 异常处理是一个术语，指在一个错误（一个异常）发生时自动执行的函数，VC++的异常处理函数： _set_new_handler(),在一个new失败时用户可以强迫异常处理程序执行自己的错误函数。_set_new_handler()自动检测所有的new操作并在必要时进行干涉。 第六天：在VC++中函数参数的传递有按值传递和引用传递两种方式。 如果接收函数改变了传送给它们的参数的值，而且这些改变在调用函数中被识别，则认为是按地址传送。 如果调用函数的参数在接收函数中保持不变则是按值传递。 所有的数组都自动被按地址传递，而不能按值传递数组，数组的名是一个指针。指针永远等于数据的地址。 任何非数组变量都可以采用引用传递，只要在接收参数表中插入一个&符号就可以表示一个变量进行引用传递。 引用传递是高效的安全的，可以在接收引用参数前加const，以防止函数无意间改变了引用参数。 在函数原型中可以声明缺省参数表，简化编程。函数不只可以声明一个缺省参数，可以按需要声明多个，还可以混合常规参数。但缺省参数必须在参数表中所有常规参数的后面。 defFun(int,flost,int=12,char='a'); //标准的函数声明，可以不带参数变量名。带上变量名可以直接拷贝到函数的第一行，但函数的第一行不要求带缺省值。 在一个程序开始运行时传入的值称命令行参数。当敲入一个或多个命令参数给一个程序时，这些参数是通过两个变量来描述，一个是一个整型变量用于保存命令参数的个数，另一个是字符指针数组用于保存这些参数。每个数组元素指向一个参数。给个例子 main(int argc,*argv[]) argc和argv是标准名字，其中*agrv[]是一个指针数组，一个数组名是一个常数指针，所以argv是一个指向其它指针的指针。而argc保存的是实际的参数个数加1，第一个用于保存dos路径和文件名。 第七天：将功能类似，但要求参数有不同的类型和数目的函数重载。 为所有的重载函数说明原型。不要仅仅改变重载函数的返回值，只有不同的参数表才能把重载函数区分开。 用户给函数一个名字但VC在调用时会将此名字进行压延成另一个名字这样用来区分重载函数。 如果用户希望不压延函数调用，需要在程序的开头插入一个非压延函数清单。 extern "c" { void cfun(int i,float x); void cfun2(float x, float y); } 重载运算符：operator...()//...表示所选择的运算符，除了？：条件操作符，：：域运算符，*间接引用运算符，.成员运算符。 在自定义数据类型上实现内部运算，使用重载运算符。不能对内部数据类型定义重载运算，也不能改变运算符的优先级别。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 第八天：抽象数据类型是指用户自定义的数据类型。虽然用户使用内部类型来定义抽象数据类型但它不是内部数据类型。 "."点操作符是访问对象变量的成员 "->"指针操作符是访问指针指向的对象变量。 包含结构类型的的结构称嵌套结构类型。嵌套结构类型可以再次被嵌套，访问被嵌套的结构成员必须用两个点操作符。 通常把类数据声明为全局性的，把类变量声明为局部的。并把类声明放在头文件中用"#include"来包含它们。 在类声明后必须有分号。可以在声明类的同时声明类变量。如下： class empData{ char empCode[8]; float wkSalary; }emp1,emp2; 　　理论上说一切变量都是对象，但VC++的对象通常是指类变量。 对象是程序声明的某类变量，对对象的声明称做对某类实例化。 类的成员缺省是私有的。 　　局部（块作用域）全局（文件作用域） 　　类作用域：如果一个变量有类作用域，那么它只能在这个类中被使用。所以即使这个类变量是函数的局部变量，它的成员也未必都能被这个函数访问。 　　两个关键字：public 和 private可以改变class和struct的member的缺省状态。 关键字public\private\protected叫做访问说明符。其中public和private决定了是否能在外部访问类或结构的成员。 第九天：成员函数有时被称为方法，因为它提供了一种严格的访问私有数据的方法。 class ABC{ int a; //数据成员 float b; //数据成员 char c; //数据成员 }; 属性描述类的初始状态，这个类的属性包括一个整数成员、一个浮点成员、一个字符成员，所有这些成员组成了ABC类的属性。 如果类中存在函数则称为成员函数（和成员数据一样成员函数也是类的成员）。成员函数便是此对象的行为。成员函数通常被设定为公有成员。（public）。 可以用点操作符调用类中的公有数据成员和成员函数。成员函数的基本目的就是控制程序的其他部分对私有数据的访问。通常私有数据和公有函数组成了一个完整的对数据提供保护的类。 file://用以上学到的概念作一个扑克牌发牌程序，和一个彩票随机出号程序。 main()函数不仅仅是一个程序的框架，还是一个高水平的组织管理系统，管理对象并且通过发送消息控制对象的行为（通过调用成员函数）。 注意：用户只有在类变量被定义后才能赋值。只定义了类是不会有内存空间分配给它，只有定义了类变量才行。这就是说不能在类定义中初始化类的成员。 一定要在成员函数中添加参数表（可以用缺省参数表），以便在以后的程序中向成员函数传递参数。 成员函数并不是只能从对象外部到内部的单向数据通道，只要在成员函数中设置一个返回值，就很容易使对象的成员函数返回一个值到main（）中。 建议为每个数据成员编写只返回一个值的只读访问成员函数，以便main（）或程序其他部分访问某个数据时使用。 只把成员函数的原型放在类中，让类成为一个头文件。（包含类的简要说明，数据成员和成员函数的原型）。把成员函数体放在类说明之后，但在main（）之前。在实际的编程中把所有的类定义放在一个类的头文件中，在程序中用"#include"包含类代码。最好是提供类的头文件，但事先把所有的成员函数代码编译好，在程序中使用它们时连接目标代码。 把成员函数放在类定义之外时，不要忘记在函数名前冠以作用域说明符。在每个成员函数前必须冠以它所属的类名和作用域说明符。这样才能使它和它所属的类匹配。格式如下： 类名：：函数名（参数表） 例： void ABC::getVals(void) 技巧：可以使用内联函数提高类的工作效率。 通过成员函数提供数据保护这样类不会被赋错误的值。 封装是指把几个元素包含在一个外壳中。封装就是把数据成员和成员函数联编在一个类中，这样对象可以拥有属性和行为两方面内容。 *this指针被隐式的传递给所有成员函数，它指向引起这次函数调用的对象。通过传递*this指针，VC++告诉成员函数对哪个对象进行操作。有一些情况下必须直接对*this进行操作，但大多数情况可以忽略这个指针的存在。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 第十天：友元函数和友元类使得程序员在不放弃私有数据安全性的情况下，对特定的函数或类进行访问。 　　要想通过一个打印函数打印类中的数据成员，要么函数是类中的一个成员，要么是友元函数。注意友元函数不是类成员，而是位于类作用域外的函数。定义友元函数时只需将它的函数原型插入类定义，象声明成员函数一样，再在函数原型前加入关键字friend即可。类本身决定友元的存在。友元函数是非成员函数，所以它无法通过this指针获得一份拷贝，因此必须给友元函数传递一个对象变量，这一点和其他非成员函数是一样的，不同的是友元函数可以访问类的私有数据。 　　友元函数必须带有某类变量为参数，才能获取对象数据并对其操作。 　　一个独立的友元函数可以访问多个类的数据，但必须同时为这多个类的友元。//注意：向前引用是类的原型说明。 　　当一个类需要访问另一个类的某几个或全部私有数据或是私有成员函数时，将其声明为友元类。友元类是一个单独的类它可以访问另一个类中的所有成员。友元类中含有一个成员，它的类型是声明了这个友元类的类。即使一个类不是友元类，它的成员也可能是其它类的对象，但是该类将无法访问其对象成员的私有成员。 file://一个例子： #include #include #include class Boyssoftball; //类声明，因为另一个类要引用到它，如友元函数，所以必须先定义。 class Girlssoftball{ char name[25]; int age; float batavg; public: void init(char N[],int A,float B); friend void prdata(const Girlssoftball p1g,const Boyssoftball p1b); }; void Girlssoftball::init(char N[],int A,float B){ strcpy(name,N); age=A; batavg=B; } class Boyssoftball{ char name[25]; int age; float batavg; public: void init(char N[],int A,float B); friend void prdata(const Girlssoftball p1g,const Boyssoftball p1b); }; void Boyssoftball::init(char N[],int A,float B){ strcpy(name,N); age=A; batavg=B; } main() { Girlssoftball *Gplayer[3]; Boyssoftball *Bplayer[3]; for(int i=0; iinit("stacy",12,1.34); Gplayer[1]->init("suci",13,2.34); Gplayer[2]->init("ketey",12,3.434); Bplayer[0]->init("tom",12,4.434); Bplayer[1]->init("jone",12,5.504); Bplayer[2]->init("hunter",13,6.496); for(int n=0; n<3; n++){ prdata(*Gplayer[n],*Bplayer[n]); } for(int j=0; j<3; j++){ delete Gplayer[j]; delete Bplayer[j]; } return 0; } void prdata(const Girlssoftball p1g,const Boyssoftball p1b){ cout< cout<<"player name:"< cout<<"player age:"< cout<<"player average:"< cout<<"player name:"< cout<<"player age:"< cout<<"player average:"< } 第十一天和第十二天： 　　当需要对自定义数据类型进行类似于对内部数据类型进行内部操作时使用操作符重载函数。 　　尽可能的编写全面的operator...()函数，以便操作符两边出现不同数据类型组合时，操作符重载依旧有效。 　　再操作符重载函数中不要将多余的参数传递进去，VC++象处理其它成员函数一样负责传送接受this指针。 　　不要远离操作符原来的意思。 　　在重载操作符两边放置同名的类变量，可以使得一个类变量为空。 可以使用友元函数编写要把内部数据类型和自定义数据类型进行操作的，操作符重载函数。 如果将与复合操作符等价的操作符重载了，最好也重载该复合操作符。如如果重载了*最好将*=也重载。这样做的好处是有助于丰富类的功能。 在重载复合操作符时一定要返回一个this指针的间接引用。这种操作符必须返回一个左边操作符被修改的备份。 　　不能精确的比较两个浮点数的值。不要轻易重载关系比较符。如与&&或||。 　　如果要把内部数据作为左操作符而自定义数据类型作右操作符时，为了防止this指针的干扰，又为了能访问类中的私有成员，所以必须用友元函数。 重载递增及递减操作符也必须返回this指针。 　　学习了输入<>操作符的重载，通过编写简单的operator<<(),掌握了一种方法，将main()函数的烦琐细节除去，交给自定义的类去处理。istream和ostream的对象是和输入输出流数据相连的，由于能够存取流中数据，就还可以编写I/O操作算子函数。 下标符号也可以重载，使得余下的程序可以访问单个的成员或成员的数组元素。使用下标符号能创建安全的数组，能实现上下界自检。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 第十三天：构造函数是成员函数。 　　当对对象数据处理结束后可以用析构函数以自定义的方式将其清除。析构函数是用来清除数据的特殊成员函数。 　　记住：构造函数和析构函数是进行对象数据的创建，初始化，清除工作的成员函数，可以重载构造函数，使一个类不止具备一个构造函数，因有时需要以这些方法中的某一种分别创建不同的对象。不能重载析构函数。 　　构造函数作为成员函数和类有相同的名字。例：一个类名为：aClass,构造函数就是aClass()。构造函数没有返回值，而且不能定义其返回类型，void也不行。析构函数同样使用这一点。当编写重载函数时，只有参数表不同，通过比较其参数个数或参数类型可以区分两个重载函数。 file://包含三个构造函数的类头 class Children{ char name[25]; int age; float Weight; public: void prData(void); char * getname(void); int getage(void); float getWeight(void); Children(void); //三个构造函数的声明； Children(int,float); Children(char *,int,float); ~Children(); //析构函数 }; 　　析构函数作为类的成员函数也具有和类相同的名字，不同的是在函数其前多了一个~符号。名为aClass的类的析构函数~aClass()。一个类只能有一个析构函数，析构函数为成员函数没有参数，没有返回值，不能重载。 　　如果构造函数为数据成员分配了内存空间，那么析构函数做的就是释放内存。只要变量在其作用域范围之内，其值都是有效的。 　　VC++在定义变量时调用构造函数，在变量出了作用域时调用析构函数。时机是自动的。 　　构造函数和析构函数应该是公用成员函数。 　　构造函数原型可以带缺省参数。但不能和空参数同时在不带参数的情况下使用。 　　当定义对象数组时，编写构造函数和析构函数。当创建数组时，VC++用构造函数构造对象数组中的每一个元素。而在出了作用域要清除数组时，由析构函数来释放所有对象。 　　创建包含指针成员的对象时，应重灾赋值操作符的函数和拷贝构造函数。 　拷贝构造函数是一种特殊类型的构造函数。它的参数是一个对象变量的引用。当根据某个对象初始化新对象时，或是通过引用传递返回对象时，需要调用拷贝构造函数。 ////////////////////////////////////////////////////////////// file://字符串类string弥补了VC++没有字符串的缺憾 file://copyrightrbg and 2000 file://Filename:StrClass.cpp ////////////////////////////////////////////////////////////// #include #include class String{ char *st; public: String &operator=(const String &); friend String operator+(const String &,const String &); friend ostream &operator<<(ostream &,const String &); String(); String(const char *); String(const String &); ~String(); }; String &String::operator=(const String &s) { if(this==&s) {return *this; } delete [] st; st=new char[strlen(s.st)+1]; strcpy(st,s.st); return * this; } String::String() { st='\0'; } String::String(const char *s) { st=new char[strlen(s)+1]; strcpy(st,s); } String::String(const String &s) { st=new char[strlen(s.st )+1]; strcpy(st,s.st ); } String::~String () { delete []st; } String operator+(const String &source,const String &tar) { if(!strlen(source.st)) return tar; else if(!strlen(source.st)) return source; String temp; temp.st=new char[strlen(source.st)+strlen(tar.st)+1]; strcpy(temp.st,source.st ); strcat(temp.st ,tar.st ); return temp; } ostream &operator<<(ostream &out,const String &s) { out< return out; } //////////////////////////////////////////////////////////////////////// main(){ String myname; String youname("zhangsan"); String hisname=youname; myname="renbugang"; cout<<"My name is:"< cout<<"You name is:"< cout<<"His name is:"< hisname="lisi"; cout<<"His name chanage:"< String ourname; ourname=myname+youname+hisname; cout<<"Our name is:"< return 0; } 第十四天：关键字static（静态），它保证了局部变量在块结束时不被破坏。 　　static放在int,float等数据类型标识符前，也可以放在自定义的数据类型名前。static也称延长生存。和全局变量的静态生存期对应的是局部变量缺省的动态生存期。 　　全局变量是静态的，不可能被定义为动态。全局变量自它的定义之处开始一直到源码结束都有效。若在全局变量的前面加上关键字static，则表示该全局变量拥有文件作用域。 　　与全局变量相仿，在函数前冠以关键字static可以限制该函数的可见性，使得其余与这个文件相连的文件无法使用它。如果别文件使用了同名的不会发生冲突。 　　如果希望另一个源文件在连接完后调用文件中的非静态函数，必须在所有调用此函数的文件中说明原型，并冠以关键字extren. 　　非静态的全局变量和函数具有外部连接性，也就是说现行源文件之外的代码也可以使用这些没有用static定义的全局变量和函数，静态全局变量和函数具有内部连接性，只有现行文件可以使用。 　　执行程序回到块中希望保持其变量的值，使用static定义其局部变量。 　　VC++为每个类仅保留一套成员函数，每个对象都有其所属类的成员函数的函数指针。 　　静态数据成员通常用来记录已创建对象的个数，例如，构造函数每次调用时将其静态成员加一，在析构函数中将相应的静态成员减一。 　　使用作用域操作符：：访问静态数据成员和成员函数，静态成员不于任何对象相连，所以必须通过类调用静态函数或访问静态成员。 　　利用静态的成员函数访问私有的静态数据成员。 　　在main()前初始化静态数据成员，在静态数据成员前加数据类型。 　　使用静态数据成员记录类的使用情况，如总计或平均值。 几个概念： 　　编译：将源代码(.cpp)转换为目标代码(.obj)。 　　目标代码：源文件的内部二进制表示形式。是机器能理解的程序格式，源代码是程序员能理解的程序格式。 　　连接：将所有的有关的目标代码连接成一个单独的可执行文件(.exe)。 　　可执行文件：程序被编译连接后的状态。 　　把程序分成几个文件，特别是类的头部和类的实现部分应该分离出来，这样能保证使用类的程序清晰易读。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 第十五天和第十六天 　　从已存在的类继承得到新类的过程叫做派生。派生是继承的过程。 用：将派生类和基类分开。派生类将继承基类所有公有成员。（构造函数和析构函数除外） 不要设计有许多私有成员的基类。 protected:被保护成员，可以被基类和派生类使用。通常基类只包括公有和被保护成员。 如果希望类外程序包括派生类都无权访问类中数据，那么将其定义为私有。 class base:private emp//取代继承时VC++提供的缺省设置方式是private.即是从基类继承到的成员在派生类全都是私有成员。 class base:protected emp//继承来的保护成员和公有成员在派生类中全部都为被保护成员。 最常用的是这种： class base:public emp//基类中的保护成员在派生类仍旧为保护成员，基类中的公有成员在派生类中仍旧为公有成员。 　　内部的缺省构造函数没有处理常量的能力。因此要求类中出现常量成员时需要自定义构造函数。并且需要利用构造初始化表，构造函数才能真正的进行构造和初始化，而不是构造和赋值。 class c{ int i; char a; float b; public: c(int i,char a,float b)://此处时冒号,构造函数原型声明，可以和初始化表在一行。 i(I),a(A),b(B){}；//此处是初始化表 } 注意：字符数组成员和指针通常被保存在堆中，故要求在函数内赋值。 类中没有数组成员时，应当用构造初始化表完成所有初始化工作。 为什么要用继承： 　　通过继承再次利用了自己编写的代码，既维持了对数据的保护，又是开发程序的有利工具。如果买来了类工具库，甚至可以在没有实现部分源代码的情况下派生出新的类来，当需要得到一个和类库所提供的不同的窗口类时，可通过继承得到一个略有不同的新窗口。 　　继承的一个优点是可以在已经了解的编写好的代码基础上编写新的代码，从已经编写并调试好的类中很容易就能够派生出新的类。通过继承复用代码和数据，比非OOP程序设计中的复用更加安全有效。 被保护的访问权限用在何处？ 　　在VC++添加被保护的访问权限是为了在维持对数据保护的情况下完成继承。派生类不能使用基类中的私有成员。 　　将基类中的某些成员定义为保护成员防止了类外的程序对其的访问，同时又允许派生类访问，被保护的成员仍旧不被余下程序所见，但所有的派生类都可以访问它。如果没有被保护访问权限就不能做到既对数据进行保护（私有性）又可以使派生类可以访问。 由一个基类得到派生类可以做那些改动。 　　可以在派生类添加数据成员和功能函数。子类总是比父类功能强大。 为什么单向继承优于多向继承？ 　　单向继承代码比多向继承代码易于编写，可以加快编程速度并可减少错误。 为什么派生类必须定义访问权限？ 　　因为在VC++中所有的派生类继承基类时缺省为私有继承。这种限制会带来不便。 　　将访问权限定义为protected将使得继承得到的公有成员和保护成员在派生类中都是保护成员。 　　将访问权限定义为public将使得继承得到的公有成员仍为公有成员，保护成员仍为保护成员，这是最通用的方式。 　　用构造初始化表后，除了能构造常量成员对象外，还可以使构造函数变的简捷，构造初始化表负责构造派生类。 　　字符数组必须在函数体内被赋值。字符数组成员和指针成员通常被保存在堆中故而要求在构造函数体内赋值。 例子程序： #include #include class Parent{ protected: char name[25]; int age; public: Parent(char[],int); ~Parent(){}; void disparent(void); }; Parent::Parent(char N[],int A):age(A){ strcpy(name,N); } void Parent::disparent (void){ cout<<"Parent's name is:"< cout<<"Parent's age is:"< } class Son:Parent{ int yrInSchool; public: void dispSon(void); Son(char[],int,int); }; Son::Son(char N[],int A,int Y):Parent(N,A),yrInSchool(Y){ } void Son::dispSon (void){ cout<<"Son's name is:"< cout<<"Son's age is:"< cout<<"Son year IN school is:"< } class Daughter:Parent{ int yrInSchool; char friendsName[25]; public: void dispDaughter(void); Daughter(char[],int,int,char[]); }; Daughter::Daughter(char N[],int A,int Y,char F[]):Parent(N,A),yrInSchool(Y) { strcpy(friendsName,F); } void Daughter::dispDaughter (void){ cout<<"Daughter's name is:"< cout<<"Daughter's age is:"< cout<<"Daughter year IN school is:"< cout<<"Daughter's FriendsName is:"< }; main(){ Parent mom("Betty",58); Parent dad("tom",60); mom.disparent (); dad.disparent (); Son boy("smalltom",17,11); boy.dispSon (); Daughter girl("ketey",18,12,"june"); girl.dispDaughter (); return 0; } 　　子类构造基类时，初始化表的参数顺序和父类的初始化表一致。这样才能将正确的值传递给父类的构造函数。 　　先构造基类对象在构造派生类对象。 　　如果需要限制或改变继承到成员的功能，在派生类中定义同名的数据成员或成员函数。 　　VC++自动析构继承对象从最低的派生类到基类。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 第十七天： 当一个类包含其他类时用合成。 当一个类是另一个类的扩展，它包含另一个类的一些属性，另外又增加了一些属性行为用继承。 一个由其他对象合成的对象在它的所有成员对象初始化之前不能被初始化。 构造合成类本身之前应该首先用构造函数初始化表构造成员类。 提供构造整个合成类所需的所有参数，包括构造类中的每个成员类的所需参数。 不需调用成员类的析构函数。 不能访问成员类的私有数据。要想访问它们必须通过调用公有成员函数。 当一个类和另一个类只有个别成员函数或数据成员不同时使用继承的方法。当一个类包含另一个或更多的类时使用合成。但合成类并不仅仅是其他类的功能扩展版本。对于继承构造函数初始化表在建立对象时扮演了重要的角色，当构造一个合成类对象时，则必须肯定所有成员元件都已被构造了。 如果合成类或某个成员元件类包含指针成员，就必须编写重载赋值函数。 第十八天： 　　在大多数程序中不使用虚函数，就使用静态联编。除非使用了函数指针或是虚函数，否则C/VC++编译器都采用静态联编方式。 　　静态联编是指在编译时而非运行时确定函数调用。此方法效率高。 　　动态联编是指在运行时才能确定函数调用。OOP中需要进行动态联编的场合是使用一个指向类家族所有类的指针。只要这个指针指向基类，就能指向任何一个派生类，编译器无法确定指针究竟指向哪个类，直到运行时才能确定。加入Virtual关键字是为了告诉编译器等到运行时在确定哪个函数被调用。基类的还是派生类的函数。 　　使用Virtual要求动态联编时，VC++在函数调用处插入一个间接指针，不是指向函数首址，而是指向虚拟函数调用地址表（指向函数首址是直接指针）这个表叫做VTABLE（Virtual Table 虚拟表）。在运行时，对象指针触发成员函数在虚拟表中的偏移量调用正确的函数。 　　纯虚函数不包括任何代码，可以选择给纯虚函数赋0值，从而使编译器不能让用户试图实例化一个包含纯虚函数的基类。 　　任何包含一个或多个纯虚函数的基类称做抽象基类。不能实例化，成员函数是空的，但可以用它作为它的派生类层次的模式，这样一个基类提供一个所有类家族中类的框架。抽象基类可以列出所有公用数据成员和成员函数，以便派生类继承。 file://Filename:1206.CPP #include #include #include #include int dispMenu(void); void addParts(void); void prParts(void); class inventoryItem{ char partCode[5]; char descrip[20]; int num; float price; public: void addToInv(char P[],char D[],int N,float PR) { num=N; price=PR; strcpy(partCode,P); strcpy(descrip,D); this->toDisk(); } void toDisk(void) { ofstream invOut; invOut.open ("INV.DAT",ios::app); invOut.write ((char *)this,sizeof(*this)); } void getData(void); }; void inventoryItem::getData (void) { ifstream invIn("INV.DAT"); while(invIn) { invIn.read((char *)this,sizeof(*this)); if(invIn.good()) { cout< cout< cout<<"\npart code:"< cout<<"description:"< cout<<"Quantitly:"< cout<<"Price:"< } } } main() { int menu; do { menu=dispMenu(); switch(menu) { case 1:addParts(); break; case 2:prParts(); break; case 3:exit(1); default: cerr<<"\n* * * Enter 1,2or3 * * *\n"; } }while(menu!=3); return 0; } int dispMenu(void) { int ans; cout<<"\n\n功能菜单:\n\n"; cout<<"1.增加记录\n"; cout<<"2.显示记录\n"; cout<<"3.退出\n"; cin>>ans; return ans; } void addParts(void) { char pc[5]; char de[20]; int q; float pr; inventoryItem part; cin.ignore (); cout<<"名称:"; cin.getline(pc,5); cout<<"说明:"; cin.getline (de,20); cout<<"数量:"; cin>>q; cout<<"价格:"; cin>>pr; part.addToInv (pc,de,q,pr); } void prParts(void) { inventoryItem part; part.getData (); } 　 其余时间自己练。。。。 　　『21天精通C++』自学笔记到此就结束了，因是一年多以前的东西了所以不是很完整，当时学的时候只记得虽然书名是21天可雷神共读了三遍用了半年的时间，自以为还没有入门？好象明白了但又什么也不能做，这是怎么回事？雷神一个劲的 @#%$%$@!@@#~￥#。不过以我的性格既然开始了就不放弃，继续学下去，我看的下一本书是『VC技术内幕』。我会把笔记补上有时间的话。 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力

本书是计算机科学方面的经典名著《编程珠玑》的姊妹篇，讲述了对程序员有共性的知识。书中涵盖了程序员操纵的技术、程序员取舍的技巧、输入和输出设计以及算法示例，这些内容结合成一个有机整体，如一串串珠玑展示给程序员。本书适合各级程序员阅读参考

有测试的需要

*

Windows Shell 编程

本书是讲解Windows操作系统内部机制的专著，作者从基本概念入手，全面系统地介绍了Windows的各种基本构件，如进程、线程、DLL和内存管理等，并列举了大量应用程序，精辟地分析了构件的使用方法，为掌握Windows编程技巧提供了一条有效的捷径。 　　作者简介： 　　Jeffrey Richter是一位在全球享有盛誉的技术作家，尤其在Windows/.NET领域有着杰出的贡献。他的第一本Windows著作Windows 3: A Developer''s Guide大获好评，从而声名远扬。之后，他又推出了经典著作《Windows 高级编程指南》和《Windows核心编程》。如今这两本书早已成为Windows程序设计领域的颠峰之作，培育了几代软件开发设计人员。他的每一本新作问世，我们都有理由相信这是一本巨著，我们想要的一切尽在其中。Jeffery 是Wintellect公司的创始人之%u4E0

初学 组件,编程,调用,函数,代码,操作系统,硬件,程序,显卡,库

技术门户网站

PowerTools 开发工具类 系统类 编程 编程工具

在所有的预处理指令中，#pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。 #pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。 依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。 其格式一般为: #pragma para 其中para为参数，下面来看一些常用的参数。

图形 算法

位运算 算法

网址