C++语言学习记录

1、左值与右值见C+primer中文版39页变量的声明与定义的区别：见C+primer中文版45页变量的两种初始化形式：int a(10)和 int a=10;关键字-register：这个关键字请求编译器尽可能地将变量存在CPU的内部寄存器中，而不是通过内存寻址访问提高效率。使用register的限制：register变量必须是能被CPU寄存器所接受的的类型。register变量必修是一个单值，并且长度小于等于整型的长度，而且寄存器变量可能不存放在内存中，所以不能使用取地址运算符&来获得寄存器register变量的地址。作用域操作符 :作用域：变量在程序中的起作用范围简单分为：全局作用域

2、、局部作用域、语句作用域作 用域优先级： 范围越小优先级越高作用域运算符：“:”如果希望在局部变量的作用域内使用同名的全局变量，可以在该 变量前加上“:” ，“:”称为作用域运算符 #include <iostream.h>int avar=10;       /全局变量avarvoid main()   int avar=20;       /局部变量avar      cout<<

3、;"avar is: "<<avar<<endl; /访问局部变量   avar=25;    /1     /修改局部变量   cout<<"avar is: "<<avar<<endl;    cout<<"avar is: "<<:avar<<endl; /访问全局变量   :avar=

4、30;   /2     /修改全局变量   cout<<"avar is: "<<:avar<<endl; 指针与引用的区别：见C+primer中文版105页C+用bool声明布尔变量，JAVA用boolean声明布尔变量。第2章从结构到类的演变class Userpublic：Uers(string str,int yy) name=str,age=yy;void print() . private  string name;int age;/

5、C+类的结尾处应该以“;”结束JAVA类定义不需要在括号后加;第3章函数与函数模板主函数C+/ 自由函数int main( int argc, char* argv) printf( "Hello, world" ); Java/ 每个函数必须是类成员；当java类运行时类中的主函数就会被调用/（所以你可以为每个类写一个主函数这样用于给类写单元测试时会很方便）class HelloWorld public static void main(String args) System.out.println( "Hello, World" ); 默认

6、参数在函数原型中说明，可以多于一个，但必须放在参数序列的后部。如果一个默认参数需要指明一个特定值，则在其之后的所有参数都必须赋值。使用默认参数就不能对少于参数个数的函数进行重载。Java语言调用方法时参数不支持缺省赋值（默认参数值），C+支持默认参数值。方法的重载（overload）和覆盖（override）的联系与区别 有的时候，类的同一种功能有多种实现方式，到底采用哪种实现方式，取决于调用者给定的参数。例如我 们最常用的System.out.println()能够打印出任何数据类型的数据，它有多种实现方式。运行时，Java虚拟机先判断给定参数的类型，然后决 定执行哪个printl

7、n()方法。 重载（overload）：对于类的方法（包括从父类中继承的方法），方法名相同，参数列表不同的方法之间就构成了重载关系。这里有两个问题需要注意：（1）       什么叫参数列表？参数列表又叫参数签名，指三样东西：参数的类型，参数的个数，参数的顺序。这三者只要有一个不同就叫做参数列表不同。（2）       重载关系只能发生在同一个类中吗？非也。这时候你要深刻理解继承，要知道一个子类所拥有的成员除了自己显式写出来的以外，还有父类遗传下来的。 所以子类中的

8、某个方法和父类中继承下来的方法也可以发生重载的关系。大家在使用的时候要紧扣定义，看方法之间是否是重载关系，不用管 方法的修饰符和返回类型以及抛出的异常，只看方法名和参数列表。而且要记住，构造器也可以重载。 覆盖 (override)：也叫重写，就是在当父类中的某些方法不能满足要求时，子类中改写父类的方法。当父类中的方法被覆 盖了后，除非用super关键字，否则就无法再调用父类中的方法了。发生覆盖的条件：1、“三同一不低” 子类和父类的方法名称，参数列表，返回类型必须完全相同，而且子类方法的访问修饰符的权限不能比父类低。2、子类方法不能抛出比父类方法更多的异常。即子类方法所抛出的异 常

9、必须和父类方法所抛出的异常一致，或者是其子类，或者什么 也不抛出；3、被覆盖的方法不能是final类型的。因为final修饰的方法是无法覆盖的。4、被覆盖的方法不能为private。否则在其子类中只是 新定义了一个方法，并没有对其进行覆盖。5、被覆盖的方法不能为static。所以如果父类中的方法 为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误。反之亦然。即使父类和子类中的方法都是静态的， 并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。 方法的覆盖和重载具有以下相同点：都要求方法同

10、名都可以用于抽象方法和非抽象方法之间 方法的覆盖和重载具有以下不同点：方法覆盖要求参数列表（参数签名）必须一致，而方法重载要求参数列表必须不一致。方法覆盖要求返回类型必须一致，方法重载对此没有要求。方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方 法）方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。父类的一个方法只能被子类覆盖一次，而一个方法可以在所有的类中可以被重载多次。 另外，对于属性（成员变量）而言，是不能重载的，只能覆盖。在定义函数时用类型参数替代实际类型，增加了灵活性，用实际类型实例化

11、这种函数，这种函数叫做函数模板。将函数模板与某个具体数据类型连用，产生模板函数。该过程叫做函数模板实例化。函数重载与函数模板的使用却别。函数模板用于只是参数类型不同动作序列完全相同即参数个数完全相同。可以减少代码量和使得代码整洁。调用函数顺序：先重载再模板最后相近。（见中科院面向对象程序设计C+ 第18讲）template<class T,class S><class T,class S>叫做类型参数表。Class也可以用typename代替。第4章类和对象4.1类及其实例化 类成员包括数据成员和成员函数。不能在类体内给数据成员赋值，但是可以通过构造函数初始化或通过成员

12、函数赋值。如果没有使用关键字，则所有成员默认声明为private权限。Java的默认访问权限叫做（无修饰，友好的friendly ）只允许同一包中的类的方法访问。赋初值与初始化的区别：赋初值是在有了对象之后，使用成员函数给数据成员赋值。初始化是产生对象时就使对象的数据成员具有指定值。初始化使用构造函数实现。4.2构造函数一旦程序定义了自己的构造函数，系统就不再提供默认构造函数。如果程序员没有再定义一个无参数的构造函数，但又声明了一个没有初始化的对象，则因系统已经不再提供默认构造函数而造成编译错误（JAVA亦如此）。定义构造函数不能指定返回类型，即使是void类型也不可以。声明对象指针时只是在内

13、存中创建了一个指针变量，只有new 对象后赋值给该指针才能调用该对象的构造函数。#include <iostream.h>class MyClasspublic:MyClass()cout<<1;void main()MyClass a,b2,*P;MyClass *p=new MyClass(); 使用运算符new用于建立生存期可控的对象，new返回这个对象的指针。New建立一个动态对象时，new首先分配足以保存Point类的一个对象所需要的内存，然后自动调用构造函数来初始化这块内存，再返回这个动态对象的地址。使用new建立的动态对象只能用delete删除，以便释放所

14、占空间。 4.10.1编译指令所有的编译指令都是以#开始，每条指令独占一行，同一行不能有其他编译指令与C+语句。（注释除外）第5章特殊函数和成员5.1对象成员的初始化1对象成员：具有某个类型的数据成员。2对象成员的说明（P105）3对象成员的初始化：A：A(参数表0)：成员1（参数表1），成员2（参数表2），成员n（参数表n）其他操作4类组合的构造函数调用顺序：先调用内嵌对象的构造函数（按内嵌时的声明顺序，先声明者先构造）。然后调用本类的构造函数。（析构函数的调用顺序相反）。若调用缺省构造函数，则内嵌对象的初始化也将调用相应的缺省构造函数。见东南大学C+程序设计2005版第28讲。5.2静态成

15、员1全局变量与静态变量的区别（C程序设计第二版，谭浩强P172）从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。从变量值存在的时间（即生存期）角度来分，可以分为静态存储方式和动态存储方式。静态变量是局部变量的一种，叫做静态局部变量。使用静态变量的目的是消除全局变量。2.自动（auto）变量不能在类体外进行赋值（因为作用域的缘故）应该在构造函数里面赋值，静态变量可以在类体外进行赋值。（自考教材P107）#include <iostream>using namespace std;class Teststatic int x;/静态变量int y;/自动变量void t

16、te(int a,int e)x=a,y=e;/成员函数内赋值 static void sfunc(int a)y=a;/ error C2597: illegal reference to data member 'Test:y' in a /static member function静态成员函数（由于没有this指针）/不能访问非静态成员。 static void sfunc(Test&r,int a)r.y=a;/只能通过对象名或指向对象的指针访问该对象的非/静态成员。;int Test:x=8;/可以编译通过int Test:y=1;/编译通不过void ma

17、in()cout<<"aa"3.静态局部变量在编译时赋初值，即只赋初值一次，在程序运行时它已经有初值。以后每次调用函数时不再重新赋初值而是保留上次函数调用结束时的值。4.静态对象：使用static 声明的类的对象。注意：构造函数在代码执行过程中，第一次遇到他的变量定义时被调用，但直到整个程序结束之前仅调用一次。析构函数在整个程序退出之前被调用，同样也只调用一次。5.类中任何成员函数都可以访问静态数据成员。静态成员函数只能通过对象名（或指向对象的指针）访问该对象的非静态成员。5.4 const对象一个const对象只能访问const成员函数，否则将产生编译错误。常

18、数据成员仍保留静态成员特征，需要在类外初始化。第六章继承与派生6.1继承和派生的基本概念C+中有两种继承：单一继承和多重继承，java只支持单一继承。6.2单一继承1.声明继承的访问控制是指如何控制基类成员在派生类中的访问属性。包括（public,protected,private）。2.在派生类中继承的基类成员的初始化，需要由派生类的构造函数调用基类的构造函数来完成，这和初始化对象成员有类似之处。3.构造函数和析构函数是不被继承的，所以一个派生类只能调用它的直接基类的构造函数。4.类中成员的访问控制声明中protected声明类的保护成员对派生类的成员函数而言，它是公有成员，可以被访问；而对

19、其他函数而言则仍是私有成员，不能被访问。5.第四种访问控制级别：不可访问（inaccessible）从基类继承来的，要么是基类的不可访问成员，要么是基类的私有成员。6.公有派生（public）基类成员的访问权限在派生类中保持不变。 私有派生（private）私有和不可访问成员在派生类中是不可访问的，公有和保护成员这时变成派生类的私有成员。 保护派生（protected）将原来的权限降一级使用，即private变为不可访问；protected变为private（VC+不是这样的，见后面实验）;public变为protected。访问控制级别实验：#include <iostream>

20、using namespace std;class A private:int x;int y;void setx(int);void showx();protected:int z;void setz(int);void showz();public:int w;void sety(int);void showy();void A:setz(int a)z=a;void A:sety(int a)y=a;void A:setx(int a)x=a;void A:showx()cout<<"x="<<x<<endl;void A:show

21、y()cout<<"y="<<y<<endl;void A:showz()cout<<"x="<<z<<endl;class B:public Aprivate:int l;public:void setl(int a) l=a;void showl() cout<<"l="<<l<<endl;void show()setz(8);/对于公有继承基类的保护成员对于派生类的成员函数来说是公有的，对于其他函数来说是私有成员 cout

22、<<"z="<<z<<endl;/基类的保护成员只能用于继承类中 /setx(6);对于公有继承基类的私有成员对于派生类的成员函数来说是不可访问的/ showx();对于公有继承基类的私有成员对于派生类的成员函数来说是不可访问的/void showx()/私有成员/cout<<"B中的x"<<x<<endl;'x' : cannot access private member declared in class 'A'/void showy()/cou

23、t<<"B中的y"<<y<<endl;'y' : cannot access private member declared in class 'A'/;class C:private Apublic:void showc()setz(9);/基类里保护成员经过私有继承变为私有成员cout<<"z="<<z<<endl;/基类里保护成员经过私有继承变为私有成员 sety(10);/基类里公有成员经过私有继承变为私有成员showy();/基类里公有成员经

24、过私有继承变为私有成员/setx(10);/error C2248: 'setx' : cannot access private member declared in class 'A'基类里私有成员经过私有派生变为不可访问/showx();/error C2248: 'showx' : cannot access private member declared in class 'A'基类里私有成员经过私有派生变为不可访问;class D:protected Apublic:void showd() / setx(45);/e

25、rror C2248: 'setx' : cannot access private member declared in class 'A'基类里私有成员经过保护派生变为不可访问/showx(); /'showx' : cannot access private member declared in class 'A'基类里私有成员经过保护派生变为不可访问 setz(9);/基类里保护成员经过保护派生还是保护成员（保护成员(保护派生)保护成员）cout<<"z="<<z<<

26、endl;/基类里保护成员经过保护派生还是保护成员;class HC:private Cpublic: void showhc()/setz(10);/error C2247: 'setz' not accessible because 'C' uses 'private' to inherit from 'A'基类里保护成员经过私有继承变为私有成员,再经过私有继承变为不可访问成员/cout<<"z="<<z<<endl;/C2247: 'z' not acc

27、essible because 'C' uses 'private' to inherit from 'A'基类里保护成员经过私有继承变为私有成员,再经过私有继承变为不可访问成员 / sety(11);/error C2247: 'sety' not accessible because 'C' uses 'private' to inherit from 'A'基类里公有成员经过私有继承变为私有成员,再经过私有继承变为不可访问成员 /showy();/error C2247: &#

28、39;showy' not accessible because 'C' uses 'private' to inherit from 'A'基类里公有成员经过私有继承变为私有成员,再经过私有继承变为不可访问成员;class HD:private Dpublic:void showhd()setz(9);/基类里保护成员经过私有派生变为私有成员（保护成员(私有派生)私有成员）cout<<"z="<<z<<endl;/基类里保护成员经过私有派生变为私有成员;class HHD:priv

29、ate HDpublic:void showhhd() /setz(9);/基类里私有成员经过私有派生变为不可见/cout<<"z="<<z<<endl;/基类里私有成员经过私有派生变为不可见;void main()A a;/a.setx(7); error C2248: 'setx' : cannot access private member declared in class 'A'/私有成员类外不能访问/a.showx(); error C2248: 'showx' : cannot

30、 access private member declared in class 'A'a.sety(6);/oka.showy();/ok/a.setz(7);'setz' : cannot access protected member declared in class 'A'/保护成员类外不能访问/a.showz();'showz' : cannot access protected member declared in class 'A' B b;/b.showx();error C2248: '

31、showx' : cannot access private member declared in class 'B'派生类公有继承下来的基类私有成员仍然是私有成员b.sety(8);/派生类公有继承下来的基类公有成员仍然是公有有成员b.showy();/b.setz(9);'setz' : cannot access protected member declared in class 'A'派生类公有继承下来的基类保护成员仍然是保护成员b.show();C c;c.showc();HD hd;hd.showhd();6.4二义性及其支

32、配规则1.如果使用一个表达式的含义能解释为可以访问多个基类中的成员，则这种对基类成员的访问就是不确定的，称这种访问具有二义性。2.使用作用域分辨符：3.派生类D中的名字N支配基类B中同名的名字N成为名字支配规则。原因为编译器自派生类沿着继承树向上搜索，总是使用最接近派生类的函数和数据版本。4.由于二义性原因，一个类不能从同一个类中直接继承一次以上，但可以使用中间类。第7章 类模板与向量编译器将类模板中的模板参数与某种特定数据类型联系起来形成特定的类（模板类）。使用模板类（通过给模板实例化参数类型指定一个数据类型）产生对象。类模板声明：template <class(typename) T

33、>在类体外面定义成员函数时必须重写类模板。类模板中的友元声明：参见C+ primer 中文版 P5531. 普通非模板类或函数的友元声明，将友元关系授予明确指定的类或函数。2. 类模板或函数模板的友元声明，授予对友元所有实例的访问权。3. 只授予对类模板或函数模板的特定实例的访问权的友元声明。向量:向量与数组的区别：向量中存储元素的多少可以在运行中根据需要动态地增长或缩小。向量是类模板具有成员函数。Vector 有四个构造函数初始化：vector<int>B(20,1)允许同类型的向量列表相互赋值。向量第一个元素也是从0开始。和数组一样也使用下标操作符。Size_type类型

34、参见C+ primer 中文版 P73Size()函数返回vector类定义的size_type型值。不能使用列表初始化向量，但可以先初始化一个数组，然后把数组的内容复制给向量。注意不能使用该方法去初始化一个已经声明或定义过的向量。a.front() 和a.begin()区别：a.front()返回的是容器A第一个元素的值a.begin()返回的是迭代器，指向容器的第一个元素泛型算法：与操作对象的数据类型相互独立的算法。第8章多态性和虚函数滞后绑定（动态联编）（late binding）支持继承的语言但不支持多态就不能说是支持面向对象编程。原来指向小空间（基类）的指针，可以指向大空间（派生类）

35、，但是只能指向它的前一部分。原来指向大空间（派生类）的指针，不允许指向小空间（基类）。指针只能继承不能逆向使用。虚特性可继承，virtual可省。当派生类中定义了一个同名的成员函数时，只要该成员函数的参数个数和相应类型以及它的返回类型与基类中同名的虚函数完全一样，则无论是否为该成员函数使用virtual,它都将成为一个虚函数。注释：最好在派生类也加上virtual以增加可读性。C+的virtual 方法与Java 的abstract方法相同。纯虚函数：在虚函数的声明后面跟“=0”。纯虚函数一旦声明不用定义。java里没有纯虚函数这个概念。C+抽象类的唯一标志是类里有纯虚函数，Java用abst

36、ract修饰抽象类。类族：如果通过同一基类派生一系列的类，则将这些类总称为类族。在成员函数内可以调用纯虚函数。因为没有为纯虚函数定义代码，所以在构造函数或析构函数内调用一个纯虚函数将导致程序运行错误。第9章运算符重载及流类库运算符重载就是函数重载Java不支持运算符重载不能重载的运算符是(. 、 : 、*、?:)不能自己定义新的运算符，只能把C+ 原有的运算符用到自己设计的类上面去。经过重载，运算符并不改变原有的优先级，也不改变它所需的操作数数目。两种形式：友元函数和类函数在友元函数形式中，该运算符函数的形参数量和该运算符“+”的操作数的数量是想等的。作为类的成员函数的运算符的形参数目比它的操

37、作数少一个。在C+中可以重载new和delete运算符，重载new时注意参数须设置为size_t，当然UINT也可以，其他的如WORD,DWORD都不行；重载delete是参数应设为void *。下面是一个例子，还模拟了构造函数与new的执行顺序：1. / 重载newdelete.cpp : main project file. 2.3. #include "stdafx.h" 4. #include "windows.h" 5. #include "iostrea

38、m" 6.7. using namespace std; 8. using namespace System; 9.10. class A 11. 12. public: 13.     A() 14.      15.         cout << "A()" << endl; 16. &#

39、160;    17.     A() 18.      19.         cout << "A()" << endl; 20.      21.     void * operator new(size_t&

40、#160;size) 22.      23.         if (m_kHeap = NULL) 24.          25.             m_kHeap = HeapCreate(HEAP_NO_SERIA

41、LIZE, 0, 0); 26.27.             if (m_kHeap = NULL) 28.              29.              

42、0;  return NULL; 30.              31.          32.33.         void *p = HeapAlloc(m_kHeap, 0, size); 34.35.   

43、      if (p != NULL) 36.          37.             +m_iNum; 38.          39.40.       

44、  cout << "New" << endl; 41.42.         return p; 43.      44.     void operator delete(void *p) 45.      46.    

45、     if (HeapFree(m_kHeap,0,p) 47.          48.             m_iNum-; 49.          50.51.        

46、; if (m_iNum = 0) 52.          53.             if (HeapDestroy(m_kHeap) 54.              55.    

47、0;            m_kHeap = NULL; 56.              57.          58.59.         cout <&

48、lt; "Delete" << endl; 60.      61.62. private: 63.     static HANDLE m_kHeap; 64.     static int m_iNum; 65. ; 66.67. HANDLE A:m_kHeap = NULL; 68. int A:m_iNum =

49、60;0; 69.70.71. int main(array<System:String > args) 72. 73.     A *a = new A; 74.     delete a; 75.76.77.     getchar(); 78.     return 0; 79. 80. 结果为：NewA()A()Del

50、ete类型转换函数：Explicit 关键字 说实话，从来没有感觉到这个关键字有用，直到今天。explicit的意思是明显的,和它相对应的一个词是implicit意 思是隐藏的。我参考了MSDN和c+标准程序库对这个关键字的描述，并参考了网络上对这个关键字的解释。现将它的使用方法和总结记录 如下：首先这个关键字只能用在类构造函数。 它的作用是不能进行隐式转换。class gxgExplicit  /没有关键字explicit的类public:   int _size;   gxgExplicit(int size)   &#

51、160;     _size = size;   ;下面是调用   gxgExplicit gE1(24);     /这样是没有问题的   gxgExplicit gE2 = 1;     /这样也是没有问题的   gxgExplicit gE3;         /这样是不行的，没有默认构造函数 

52、0; gE1 = 2;                 /这样也是没有问题的   gE2 = 3;                 /这样也是没有问题的   gE2 = gE1;       

53、;        /这样也是没有问题的 但是假如gxgExplicit修改为Stack，我们的_size代表的是堆栈的大小，那么调用的第二句就显得不伦不类，而且容易让人疑惑。这并不是可以让代码阅读者 明白和接受的形式，虽然它是合法的（编译器可以通过编译）。这是因为编译器默认情况下有隐式转换的功能，你输入gE2 = 1就编译成同第一句相同的结果。所以，explicit就派上了用场。修改代码为：class gxgExplicitpublic:   int _size;   explicit gxgExplicit(int size) &#