内容发布更新时间 : 2024/5/22 4:45:18星期一 下面是文章的全部内容请认真阅读。

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 class A {

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 class Complex {

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 class A {

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 void main() {

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 class Complex {

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 int f(int i){ return i*i; }

float f(float x, float y){ return x*x + y*y; }

38. 函数模板：

template

返回类型 函数名（函数模板形参表） {

函数体 }

template //模板形参为T T abs(T x) //函数模板 {

if (x >= 0) return x; else return –x;}

39.分析程序的运行结果：

#include int add(int x, int y=8); void main() {

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 class Student {

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 class A {

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 #include “cylinder.h” #include “circle.h” void main() {

circle s1(10); cylinder s2(2,5);

count<<”圆柱体表面积：“<

44. 下面是一个类的测试程序，设计出能够使用如下测试程序的类：(绿色是添加的，未经测试)

（1）#include class Test {

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