1.面向过程的程序设计中，程序是由函数作为模块组成的。而在面向对象的程序设计中，程序是由类的实例—对象构成的。在面向过程的程序设计中，函数是将逻辑上相关的语句与数据封装，它的最大特点是在程序设计中数据和操作分离；而在面向对象的程序设计中对象将函数与数据封装，其最大特点是在程序设计中数据和操作作为一个整体来处理。P2
2.面向对象程序设计是从所要处理的数据入手，而结构化程序设计是从系统的功能入手。P2
3.类是对一组相同特征对象的抽象描述。对象为类的一个实例。P6 4.面向对象编程方法的基本特征：抽象、继承、封装、多态性。P8
5.新类继承了原始类的特性，新类称为原始类的派生类或子类，而原始类称为新类的基类或父类。派生类可以从它的基类那里继承类特性和方法，继承性很好地解决了软件的可重用性问题。P8
6.封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面，外界可以访问共有数据及公有成员函数，而不能访问类中的私有数据及保护数据，而成员函数可以访问类的私有数据、保护数据及公有数据。（private——私有，protected——保护，public——公有）。
7.在类体中不允许对所定义的数据成员进行初始化，C++规定，只有在类对象定义之后后给数据成员赋初值。(有可能出条错题) 8.构造函数的特点：
1)构造函数是一种特殊的成员函数，该函数的名字必须与类名相同，函数体可以写在类体内，也可以写在类体外。 2)构造函数的功能是给对象初始化。
3)构造函数不允许有返回值，也不允许定义构造函数的返回值类型，其中包括void类型，它有隐含的返回值，改值由系统内部使用。 4)程序中不能直接调用构造函数，在创建对象时系统自动调用构造函数即构造函数可以有一个或多个。
9.析构函数的特点：
1）析构函数的名字与其类名称相同，并在名称的前面加上 “~”符号。 2）析构函数不指定数据类型，包括void，并且也没有参数。 3）析构函数是成员函数。函数体可以写在类体内或类外。 4）一个类只可以定义一个析构函数。
5）析构函数被系统自动调用，当被定义在一个函数体内的对象，当这个函数结束时，该对象的析构函数被自动调用。
60如果一个对象是使用new运算符被动态创建的，则用delete运算符释放它时，delete会自动调用析构函数。
10.友元函数的特点：
1)友元函数的特殊性：友元函数拥有访问类的私有数据成员的权力，普通性在于它是一个普通的函数，除了上述的特殊性以外，与其他函数没有任何不同。
2)友元函数在声明时，前面加上关键字friend，但是破坏了数据的封装性和隐蔽性, 友元函数不是成员函数。 例： friend 类型 函数名()
11.构造函数、析构函数、拷贝初始化构造函数 都是类的成员函数，友元函数不是成员函数。
12.构造函数是在（创建对象）时被执行。
13.下列的各类函数中（友元函数）不是类的成员函数 14. 类对象对成员的引用方法：对象名.成员名 对象名.成员函数名(参数表)P51
15.C++中的注释分两种：C语言中经常使用的以“/*”开始，以“*/”结束的注释形式，一般用于多行的注释，以“//”开始的单行注释形式，/* code */ 多行注释。P23
16.C++ 中的输入输出：
cin 为键盘输入类的系统默认对象，cout< cout 为屏幕输出类的系统默认对象，cin>>x;表示从输入流cin中提取X的值。P24 17.默认函数参数：一个函数可以有多个默认参数，但是，所有的默认参数必须列在参数表的最后。即只能从右往左缺省。 例: int f1(int x, int y=0, int z = 0) ; //正确，z为默认参数 int f1(int x, int y=0, int z ) ; //错误， z不能成为默认参数 18.引用和普通变量区别：引用主要用来向函数传递参数，以及从函数中返回值。引用指对变量或对象取一个别名，也就是说引用和原变量共用一个地址，把某个变量的地址看作是该变量的别名。当初始化一个引用时就将它和一个变量联系起来，这个引用将一直与变量相联系，以后就不能将它改变为其他变量的引用。P30 19.引用参数：类型 &引用名=变量名 例：int &x = num; 20.与其他数据类型不同的是类的定义中不仅可以有数据，即数据成员，还可以有对数据进行操作的函数，即类的函数成员。因此，类是一种用户所定义的数据类型，类是相关联的数据项以及对这些数据项操作的集合。 21. 什么是对象？什么是类？类与对象的关系是什么？ 对象：一般认为对象是现实世界中的一个实际存在的事物，它可以是有形的也可以是无形的，对象具有自己的静态特征与动态特征。 类：是对一组相同特征对象的抽象描述。在面向对象的方法中，类是具有相同操作功能和相同的数据格式或属性的对象的集合，它是针对某一类对象的特性描述，也就是说运用抽象的方式描述这类对象。类为对象集合的抽象，它规定了这些对象的公共属性和方法，对象为类的一个实例。 关系：对象为类的一个实例。 22. 使用友元函数或友元类的成员函数可以访问类的私有成员P76 23. P91隐含this指针的例子。 I=x; //与this->i=x;一样 24. C++中的运算符除了少数几个（类属关系运算符“.”、作用域分辨符“：：”、成员指针运算符“*”、sizeof运算符和三目运算符“？：”）之外，全部可以重载，而且只能重载C++中已有的运算符，不能臆造新的运算符。 25. 1）重载的运算符要保持原运算符的意义。如原先单目的运算符只能重载为单目的，不能重载为双目运算符。2）只能对已有的运算符重载，不能增加新的运算符。3）输入运算符“>>”和输出运算符“<<”必须重载为友元函数，因输入运算符和输出运算符重载时，无法重载在系统的流库内，因此只能重载为友元函数。 26. 运算符号 new 和 delete New 申请一块新的内存空间，并传回分配空间的指针。 Delete 释放由new申请的空间 动态分配用new,动态删除或释放由new申请的空间用delete 例： int *p; p= new int(6); delete p; 27.类的定义： class 类名 { private: 私有数据及成员函数； protected: 保护数据及成员函数； public: 公有数据及成员函数； } 例：class Human { private: int h; char sex[3]; int age; public: void CanSay(); void CanWalk(); Void Show(); } 关键字public，private和protected被称为访问权限修饰符或访问控制修饰符。它们在类体内与出现的先后顺序无关，并且允许多次出现，用它们来说明类成员的访关权限。在一个类中若没有特别说明，则其类的数据成员和成员函数均为私有数据。（公有、私有与顺序无关，数据是私有，函数是公有的） 28. 描述一个圆柱类，成员中私有数据半径r及高h，初始化此类的一个对象， 编写一个main函数测试。P101 代码：(未经测试的代码) class Cylindrical { private: float r, h; public: Cylindrical(int x, int y); void print(); }; Cylindrical:: Cylindrical(float x, float y) { r = x; h = y; } Cylindrical::print(){ cout <<”r=”< } void main() { Cylindrical c(2.1, 10.2); c.print(); } 29.分析程序运行结果： #include public: A(); A(int i, int j); void print(); private: int a, b; } A::A() { a = b = 0; cout << “Default constructor called.\\n”; } A::A(int I, int j) { a = i; b = j; cout<<”Construtor called.\\n”; } A::print(){ cout << “a=”< } void main() { A m, n(4,8); m.print(); n.print(); } 运行结果：(未经测试的代码) Default constructor classed Construtor called. a = 0 b = 0; a = 4 b = 8; 30.This指针： 当某一对象调用一个成员函数时，指向产生这个调用的对象的指针将成为一个变元传给该函数，这个指针就是this指针。This指针可以访问对象内除静态成员外的所有成员。 例：class myclass { int i; float y; void func(int x, float y); }; void myclass::func(int x, int y) { i=x; //与this->i = x;一样 j=y; //与this->j = y;一样 } 31. 运算符重载的定义形式： (1)成员函数重载运算符的一般形式 <返回类型> <类名>::operator<重载运算符>(参数表) { 函数体 } (2)友元函数重载运算符的一般形式 Friend <返回类型> operator<重载运算符>（参数表） { 函数体 } 成员函数重载运算符例： #include private: double real; double image; public: Complex(void):real(0), image(0){}; Complex(double rp):real(rp), image(0){}; Complex(double rp, double ip):real(rp), image(ip)(); ~Complex(){}; Complex operator+(const Complex &x) const; Complex operator/(const Complex &x) const; int operator==(const Complex &x) const; Complex& operator=(const Complex &x); Complex& operator+=(const Complex &x); void Print() const; }; void Complex::Print(void) const { cout<<”(”< } Complex Complex::operator+(const Complex &x) const { return Complex(real + x.real, image+x.image); } Complex Complex::operator/(const Complex &x) const { double m; m = x.real * x.real + x.image * x.image; returm Complex((real*x.real + image*x.image) / m, (image*x.real – real*x.image)/m); } int Comlex::operator==(const Complex &x) const { Return (real == x.real && image == x.image) ? 1 : 0; 1 } Complex& Complex::operator= (const Complex &x) { real = x.real; image = x.image; return *this; } Complex& Complex::operator+=(const Complex &x) { real += x.real; image += x.image; Return *this; } Void main() { Complex a(3,5), b(2,3), c; c = a + b; c.Print(); c = a/b; c.Print(); a += b; a.Print(); } 运行结果： （5，8i） （1.61538， 0.0769231i） （5，8i）38. 32.编写一个函数，用引用的方法交换两个变量的值： #include void swapInt(int &a, int &b){ int temp; temp = a; a = b; b = temp; } void main() { int num1, num2; num1 = 5; num2 = 10; cout << “num1=” << num1<< “ “; cout << “num2=” << num2 << endl; swapInt(num1, num2); cout << “num1=” << num1<< “ “; cout << “num2=” << num2<< endl; } 输出结果为 num1=5 num2=10 num1=10 num2=5 33. 虚拟函数： 定义是用关键字virtual class 类名称 { //类的其他成员 virtual 函数类型 函数名（参数列表）; //把此函数说明为虚拟函数 }; #include public: virtual void show() { cout << “class A show() is called.”< } class B: public A { public: void show() { cout << “class B show() is called.”< }; void main() { A demo1, *ptr; B demo2; ptr = &demo1; ptr->show(); ptr=&demo2;//基类指针指向派生类对象，利用基类指针调用虚函数。 ptr->show(); } 执行结果： class A show() is called. class B show() is called. 34.分析程序运行结果： #include int num = 500; int &ref = num; cout << ref; ref = ref + 100; cout << “ “ << num; num = num + 50; cout << “ “ << ref << endl; } 运行结果 500 600 650 35. 纯虚函数定义方法： （1）virtual 函数类型 函数名称 (参数序列) = 0; 即将普通虚拟函数设置为0。声明为纯虚函数之后，基类中做不再给出函数 的实现部分。、纯虚函数的函数体由派生类给出。例 class Obj { public: virtual void Disp() = 0; } （2）一个类可以有许多个纯虚函数，包含有纯虚函数的类称为抽象类。对于抽象类来说，不能说明抽象类的对象，但可以定义一个指向它的指针。 （3）设计一个抽象类shape,它表示具有形状的东西，体现了抽象的概念，在它下面可能派生出多种具体形状，比如矩形、圆 #include (iostream.h) class shape class.rectangle:public shape { public rectangle (int x ,int y) { length=x ; width=y; } double area(){ return length*width; } private: double length ,width }; class circle:public shape { public: circle (int x) { radius = x ; } double area ( ) { return(3.14*radius*radius); } privae: double rading; }; void showarea(shape&s) {cout < void main() { rectangle a(2,4); showarea(a); circle b(5); showarea9b); } 36.友元函数重载的例子： #include friend Complex operator+(const Complex &x, const Complex &y); friend Complex operator/( const Complex &x, const Complex &y); friend int operator==(const Complex &x, const Complex &y); friend Complex& operator+=(Complex &x, Complex &y); private: double real; double image; public: Complex (void) :real(0), image(0){}; Complex(double rp) :real(rp), image(0); Complex(double rp, double ip):real(rp), image(ip) {}; ~Complex(){}; void Print(void ) const; }; void Complex::Print(void) const { cout <<”(“< Complex operator+(const Complex &x, const Complex &y) { return Complex(x.real + y.real, x.image + y.image); } Complex operator/(const Complex &x, const Complex &y) { double m; m = y.real * y.real + y.image * y.image; return Complex ((x.real * y.real + x.image * y.image)/m, (x.image*y.real – x.real*y.image) / m); } int operator==(const Complex &x, const Complex &y) { return (x.real == y.real && x.image == y.image) ? 1 : 0; } Complex& operator+= (Complex &x, const Complex &y) { x.real += y.real; x.image += x.image; return x; } void main() { Complex a(3,5), b(2,3), c; c = a + b; c.Print(); c = a/b; c.Print(); a += b; a.Print(); } 运行结果与上一个一样 注：输入运算符”>>”和输出运算符”>>”必须重载为友元函数，因为输入运算符重载时，无法重载在系统的流库内， 37.函数的重载：指函数名一样，参数个数类型有区分，即同一个函数名可以对应多个函数的实现。 例： #include float f(float x, float y){ return x*x + y*y; } 38. 函数模板： template 返回类型 函数名（函数模板形参表） { 函数体 } template if (x >= 0) return x; else return –x;} 39.分析程序的运行结果： #include int a(5); cout << “sum1 = ” << add(a) << endl; cout << “sum12= ” << add(a, add(a)) << endl; cout << “sum13= ” << add(a, add(a, add(a))) << endl; } int add(int x, int y){ return x + y; } 运行结果 13 18 23 40. 构造函数的执行顺序是先执行基类的构造函数，再执行派生类的构造函数；析构函数的执行顺序是新执行派生类的析构函数，再执行基类的析构函数。 派生类不含对象成员时构造函数的格式 派生类构造函数名（参数表）： 基类构造函数名（实参表） { //新增成员初始化语句； } 附段代码： #include int x; public: Student(int n) //基类构造函数 { cout<<”constructing student.\\n”; x = n; } ~student() //基类析构函数 { Cout<<”destructing student.\\n”; } void showx() { cout << x << endl; } }; Class Stu: public Student { int y; public Stu(int n, int m): student(m) //定义派生类构造函数时，传递一个参数给基类构造函数 { cout<<”construting Stu.\\n”; y = n } ~Stu() //派生类析构函数 { cout << “destructing Stu.\\n”; } void showy() { cout << y << endl; } }; void main() { Stu tp(10,20); Tp.showx(); Tp.showy(); } 程序运行结果： Constructing student Constructing Stu 20 10 Destructing Stu Destructing student 41. 缺省参数的构造函数： 例：#include private: double x; double y; public: A (double i = 0.0, double r = 0.0); double sum(); }; A::A (double i , double r){ x = i; y = r; } double A::sum() { double s; s = x + y; return (s); } void main() { A Y1; A Y2(2.2); A Y3(3.3, 4.4); cout << Y1.sum() < } 42.单继承：从现有的一个基类创建一个新类的过程，语法： class 派生类名: [public/private/protected] 基类名 { <派生类数据成员和成员函数定义> } 此派生中，默认为private，即私有继承 43.circle.h//定义圆类 # ifndef circle –H # define circle-H class circle { protected: double radins; public: circle (double r); void setradius (double r); double getradius (); double area (); 2 }; #endif #include”circle.h” circle::circle(double r){ radius =r; } void circle::setradius(double r){ radius=r; } double circle::getradeus(){ return radius ; } double circle::area(){ return 3.14*radius*radius; } cylinder.h #include “circle.h” class cylinder:public circle { double height; public: cylinder (double r,double h); void setheight(double h); double getheight (); double area(); }; cylinder.cpp #include”circle.h” #include”cylinder.h” cylinder::cylinder(double r,double h):circle? { height=h; }void cylinder::setheight (double h){ height=h; } double cylinder::ghtheight(){ return height; } double cylinder::area(){ return 2*circle::area()+2*3.14*radius*height; } #include circle s1(10); cylinder s2(2,5); count<<”圆柱体表面积：“< 44. 下面是一个类的测试程序，设计出能够使用如下测试程序的类：(绿色是添加的，未经测试) （1）#include private: int x, y; public: void init(int I, int j); void print(); }; Test:init(int i, int j) { x= I; y = j; } Test:print() { cout < } void main() { Test a; a.init(); a.print(); } （2）void main ( ) { Test a; a. init (68,55); a. print ( ); } 测试结果：68-55=13