大学C++程序设计教程期末复习重点

第一章

1.cin与count的应用<iostream>

例：

cin>>a;

cout<<"hello"<<endl;

cout<<he<<15<<endl;

cout.wtdth(10);//cout.fill("*")；

调整字段宽度的函数int width()：

a、控制符int width()将用来调整字段的宽度，因为width是成员函数，所以要通过对象来调用，比如cout.width()将显示当前的字段宽度，默认为0，而cout.width(3)将把字段宽度设定为3。

注意C容纳字段的方式为给字段分配刚好合适的宽度来容纳字段，所以C中默认的字段宽度为0，以适合于所有的字段。

b、width的默认对齐方式为右对齐，即如果cout.width(12)如果字段没有这么宽，则将在字段的左边填以空格来达到12个字段的宽度。

c、还要注意的是width只影响他设置后的下一个输出，再下一个字段输出后，后继的字段被恢复为默认值，比如cout.width(12); cout<<2<<3;则输出2时会以12字段的宽度显示，但显示3时就会以默认的方式显示了。

d、int width()调用他时将会反回上一次的字段宽度的值。

填充字符：成员函数fill()可以用来改变填充的字符，比如cout.fill(‘’)，使用填充空白部分。fill函数在设置后将一直有效，除非被重新设定。

cout<<setfill("*")<<20<<endl;

setw设置输出长度，setfill设置如果输出的整型不够长用什么填充

2.注释：

2.1

/* 这是注释 */

/* C++ 注释也可以

* 跨行

*/

2.2 //

3.main函数

main函数是C程序的入口函数，C标准要求main()函数的返回值类型为int。

3.1.函数内并可以不出现return语句

当main()函数的返回值为int，而函数内并没有出现return语句时，同样可以通过编译并正常运行。这是因为编译器在main()函数的末尾自动添加了return 0;的语句。所以，main()函数是C++程序经过特殊处理的函数。其他的返回值类型不是void的函数，如果没有使用return语句，编译器将报错。

3.2.main()函数被称为“入口函数”，那main()函数一定是程序中的第一个被执行的函数吗？

考察如下程序。

#include <iostream>
using namespace std;
class A{
public:
    A(){
        cout<<"In default A constructor"<<endl;
    }
};
A b;
int main()
{
    cout<<"In main()"<<endl;
    return 0;
}

编译运行以上代码输出：

在这个程序中，先输出的“In default constructor”，然后输出的是“In main()”。可见，对象a的构造函数是先于main()函数执行的。实际上，所有的外部对象的构造函数都是先于main()函数执行的。如果要对类中的成员对象进行初始化，那么这些对象的构造函数也是在main()函数之前执行的。如果在这些构造函数中还调用了其他函数的话，就可以是更多的函数先于main()函数之前运行。因此main()函数不一定是C++程序的第一个被执行的函数。

3.3.main()函数可以带参数

main()函数带参数是用来提供用户向程序输入参数。main()所带的参数有固定格式，即int main(int argc,char* argv[])，其中argc代表参数的个数，argv数组中的每一个元素则保存命令行参数内容的字符串。考察如下程序。

#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    if(argc>1)
    cout<<"Hello "<<argv[1]<<endl;
    return 0;
}

假设此程序经过编译之后生成的main.exe，那么在控制台输入”main.exe LVLV”，会输出“Hello LVLV”。使用命令行参数时注意以下几个问题。

（1）命令行输入的程序名称为程序的第一个参数，以上程序中argv[0]保存的是main.exe，尽管输入的只有一个参数”LVLV”，但是参数数量argc包含了程序名称，因此argc等于2。在其他编程语言（如C#）中，命令行参数并不包含执行文件的名字。

---

（2）在命令行中，空格被认为是命令行参数的分割符。也就是说，也就是说同一个参数内部不允许出现空格。如果在一个参数中出现空格，可以使用双引号括起来。如输入main.exe “LVLV and JF”。

4.标识符的命名规则

*一个合法的标识符只能由数字、字母、下划线、美元符号$组成，不能含有其他符号（不能有空格）

*不能以数字开头

*严格区分大小写

*关键字不能做标识符

---

第二章

1.C++数据类型

1.1基本类型（Byte ,short ，int ，long ，double float ，char ，Boolean）

整型：短整型，整型，长整型

字符型：

布尔型：

实型：浮点型，精度型

1.2指针

1.3构造类型

数组

枚举型

结构体

共用体

类

2.bool

*只有 true,false

在底层储存的时候Boolean类型占据一个字节，因为实际存储的时候FALSE的底层是0，true底层是1.

布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句中。

实际上，所有非0的整数值都被编译系统认为是true

Boolean A= false; if(A) { }

3.变量的初始化:

int a=3;
int a(3);

4.++ --

"++""--"都为单目运算符

作为运算符来说"++""--"的优先级较高，高于所有算数运算符和逻辑运算符，但是使用这两个运算符时要注意它们的运算对象只能是变量，不能是其他表达式

例:(i+j)++就是一个错误的表达式

5.const

const <类型说明符><常量名>=<常量值>

const int maix=255;

注意：使用const修饰的变量实际上是常量，不能被程序改变，因此在声明时一定要进行初始化赋值。常量变量一经生成，其值不能改变，如果在以后的执行语句对常量变量进行赋值就会导致编译错误！！！！！

const还可以用于修饰函数的参数，同样也不允许出现对它们的赋值操作

6./是除，%整除取余

---

第三章

1.C++的控制结构p47

1.1顺序结构

1.2选择结构

if switch

1.3循环结构

for while do..while

2.p68

a.编写计算n!的程序

#include<iostream>
using namespace std;
int main()
{   
    int n,i,m;
    cin>>n;
	for(i=1;i<=n;i++)
	m=m*i;
	cout<<m<<endl;
	return 0;
}

b.求1+2+3+4······+99+100的和

#include<iostream>
using namespace std;
int main()
{
    int t=1;
	int n;
	for(n=1;n<=100;n++)
	{
		t=t+n;
	
	}
cout<<"1到100的累加和为："<<t<<endl;
return 0; 
}

第四章

1.数组的定义

1.1下标从0开始

int a[2][3];

例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下：

double balance[10];

1.2初始化数组

在 C++ 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

如果您省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果：

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例：

balance[4] = 50.0;

上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。

以下是上面所讨论的数组的的图形表示：

2.P76 字符串处理库函数<cstring>

1* strcpy(s1, s2);

复制字符串 s2 到字符串 s1。

2* strcat(s1, s2);

连接字符串 s2 到字符串 s1 的末尾。

3* strlen(s1);

返回字符串 s1 的长度。

4 strcmp(s1, s2);

如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。

5 strchr(s1, ch);

返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。

6 strstr(s1, s2);

返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

eg:

#include <iostream>
#include <cstring>
 
using namespace std;
 
int main ()
{
   char str1[11] = "Hello";
   char str2[11] = "World";
   char str3[11];
   int  len ;
 
   // 复制 str1 到 str3
   strcpy( str3, str1);
   cout << "strcpy( str3, str1) : " << str3 << endl;
 
   // 连接 str1 和 str2
   strcat( str1, str2);
   cout << "strcat( str1, str2): " << str1 << endl;
 
   // 连接后，str1 的总长度
   len = strlen(str1);
   cout << "strlen(str1) : " << len << endl;
 
   return 0;
}

编译执行后结果:

strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10

3.编程实现两个字符串的连接（数组，类string）

#include <iostream>
#include <string>
using namespace std;
int main()
{
char *cat(char *a,char *b);
char s1[50] = "please ",*s2 = "let me in.";
puts(cat(s1,s2));
return 0;
}
char *cat(char *a,char *b) 
{
    char *p = a,*q = b; 
    while(*p++);
      p--;
    while(*p++ = *q++);
     *p = '';
    return a; 
}

第五章*

1.函数的定义

函数必须先定义后才能使用

<函数值类型> 函数名（<形式参数表>）

2.函数的参数传递

2.1传值

2.1.1传地址值（指针）

该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

2.1.2传变量值

该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。

2.2传引用[P97例5-4]

该方法把参数的引用（小名）复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 [P97例5-4]利用引用编写交换函数swap（） 程序代码如下：

#include<iostream>
using namespace std;
void swap(int &x,int&y)
{
    int tmp=x;
    x=y;
    y=tmp;
}
int main()
{
    int a=2,b=3;
    cout<<"Before exchange:a="<<a<<",b="<<b<<endl;
    swap(a,b);
    cout<<"After exchange:a="<<a<<",b="<<b<<endl;
    return 0;
   
}

编译执行后结果:

Before exchange:a=2,b=3
After exchange:a=3,b=2

3.P102 带有默认参数的函数的声明

（1）所有的默认参数均需放在参数表的最后

eg:

void func(int x,int n1=1,int n2=2);

若使用func（5，4）；的方式调用该函数，则X的值为5，n1的值为4，n2的值为2。

（2）默认参数的声明必须出现在函数调用前

第六章

1.*与& p119【再看看书上】

1.1“&”称为取地址运算符

返回变量的地址。例如 &a; 将给出变量的实际地址。

1.2“*”称为指针运算符（取内容运算符）

指向一个变量。例如，*var; 将指向变量 var。

2*. new与delete 学会灵活运用p125

2.1new

<指针> = new <类型>

<指针> = new <类型>（<初值>）；

2.2delete

delete <指针>

3.数组

new运算符也可以为数组申请内存，其用法如下：

<指针> = new <类型> [<元素数>]；

若释放数组的空间，必须放一个空的方括号“[]”在操作符delete和指向该类对象数组的指针之间

eg；

int *p =new int[size];
delete []p;

第七章

1.函数重载的特点P145

a.通过重载，可以将语义、功能相似的几个函数用同一个名字表示，这样便于记忆，且提高了函数的易用性；

b.面向对象理论中的类的构造函数需要重载机制。因为构造函数与类名相同，所以如果想用几种不同的方法创建对象，其对应的构造函数缺被限制只有一个名字，这时只能靠重载来实现，所以累可以有多个重名的构造函数

2.内联函数p150

将函数体的代码直接插入到函数调用处来节省调用函数的时间开销【用空间换时间】

被频繁调用，语句少，无循环语句

2.1关键字 inline

2.2注意事项 p151

（1）在C++程序中，除了在函数体中含有循环、switch分支和复杂的嵌套的if语句的函数外，所有函数均可被说明为内联函数

【内联函数不包含循环语句】

（2）内联函数大多都是小函数，其函数体不宜过大，一般宜在1到5行之间。

（3）关键字inline与函数定义放在一起才能使函数成为内联，内联函数的定义必须出现在对该函数的调用之前。这是因为编译器在对函数调用语句进行代换时，必须事先知道代换该语句的代码是什么。不然即使在函数的声明和函数的定义处均加上关键字inline都不行。

（4）由于计算机的资源有限，使用内联函数虽然节省了程序运行的时间开销，但却增大了代码占用内存的空间开销。因此具体编程时，应仔细的权衡时间开销与空间开销之间的矛盾，以确定是否采用内联函数。

第九章

1.面向对象的4个特征

抽象，封装，继承，多态

2.类的声明【声明时不能初始化】

class
{
   ······
   y;
}

3.类的成员有数据成员 和成员函数 ++ ；访问权限有私有（private），公有（public）， 保护（protected）

4.成员函数在类外如何定义（作用域）

<类型><类名>::<函数名>(<参数表>) {<函数体>}

5*.定义一个Dog类，包含name，age，sex，weight等属性以及对这些属性的操作方法。实现并测试这个类。P210 习题1

#include <iostream>
#include <cstring>
using namespace std;
class Dog
{
    char name[20];
    char sex;
    int age;
    float weight;
public:
    void Register(char * Name,int Age,char Sex,float Weight);
    char * GetName()
    {
       return name;
        
    }
    int GetAge()
    {
    return age;
    
    }
   char GetSex()
   {
   return sex;
    
   }
   float GetWeight()
   {
   return weight;
       
   }
   void Speak()
   {
   cout<<"Arf!Arf!"<<endl;}
   };
   void Dog::Register(char * Name,int Age,char Sex,float Weight)
  {
  strcpy(name,Name);
  age=Age;
  sex=Sex;
  weight=Weight;
  }
int main()
{
  char name[20];
  char sex;
  int age;
  float weight;
  Dog dog1;
  cin>>name>>age>>sex>>weight;
  dog1.Register(name,age,sex,weight);
  cout<<"Dog ’ s name:"<<dog1.GetName() <<endl;
  cout<<"Dog ’ s age:"<<dog1.GetAge()<<endl;
  cout<<"Dog ’ s sex:"<<dog1.GetSex()<<endl;
  cout<<"Dog ’ s weight:"<<dog1.GetWeight()<<endl;
  cout<<"Dog speak:";
  dog1.Speak();
  return 0;
  }

第十章

1*.构造函数的定义

类的一个特殊的成员函数，用来处理对象的初始化，每次生成类对象（实例化）时自动被调用

格式：<类名>（<参数表>）；

2*.构造函数的特点

2.1构造函数与类同名，且没有返回值类型 2.2构造函数既可以在类外定义，也可以作为内联函数在类内定义 2.3构造函数允许重载

3.拷贝构造函数 p217

构造函数的形参还可以是本类的对象的引用，其作用是用一个已经存在的对象去初始化一个新的同类对象，也称为拷贝构造函数 格式

classname (const classname &obj) {
   // 构造函数的主体
}

4.析构函数的定义及特点

4.1作用：对象消亡时，自动被调用，用来释放对象占用的空间【先析构再delete】

4.2特点:

(1) 析构函数的名字与类名相同，只需在前面需要加上波浪号"~"以与构造函数分开

(2) 构造函数不带有任何参数，因此不能重载

(3) 无析构函数没有返回值

(4) 一个类最多只有一个析构函数

5*.p236 习题1

#include＜iostream>

#include＜string>

using namespace std;

class Dog

{

string name;

char sex;

int age,weight;

public:

Dog():name("dog2"),sex('f'),age(2),weight(50) {} // 无参数初始化表

Dog(string Name,char Sex='m',int Age=3,int Weight=40); //带默认值的构造



void print();

};

Dog::Dog(string Name,char Sex,int Age,int Weight):name(Name),sex(Sex),age(Age),weight(Weight)

{
    
}

void Dog::print()//输出信息

{

cout＜＜"name is:"＜＜name＜＜endl;

cout＜＜"sex is:"＜＜sex＜＜endl;

cout＜＜"age is:"＜＜age＜＜endl;

cout＜＜"weight is:"＜＜weight＜＜endl;

}

int main()

{

string N="dog1";
char S;

int A,W;

/**************************************

有默认参数的构造函数

**************************************/ cout＜＜"使用有默认值的初始化:"＜＜endl;

cout＜＜"没有输入前的默认参数为:"＜＜endl;

Dog dog1(N);

dog1.print();

//输入数据

cout＜＜"输入狗名,年龄,性别,体重"＜＜endl;

cin>>N>>A>>S>>W;

Dog dog(N,S,A,W);

cout＜＜"输入数据后:"＜＜endl;

dog.print();

/********************************************** 使用初始化表

**********************************************/ Dog dog2;

cout＜＜"调用系统无参数初始化表:"＜＜endl;

dog2.print();


return 0;

}

第十一章

1.派生类的声明 P239

声明格式：

class 派生类名：继承方式 基类名1，继承方式 基类名2
{
    新增加的成员声明；
}

2.继承方式公有继承（public），私有继承（private），++保护继承（protected）++p239

3.公有继承 p249 表11-1

public（公用的）：既可以被本类中的成员函数所引用，也可以被类的作用域内的其他函数（即类外）引用。【在派生类内和外部都可以访问】

private（私有的）：只能被本类中的成员函数引用，类外不能调用（友元类除外）

protected（受保护的）：不能被类外访问，但可以在派生类的成员函数访问。

可以这么简单的认为：

1、凡是基类中私有的，派生类都不可访问。

2、基类中除了私有的成员，在派生类中的访问属性总是 以安全性高{ 继承方式，基类的访问属性 } 的方式呈现。（安全性级别：私有>保护>公有）

4.

派生类构造函数执行的顺序

（1）调用基类构造函数，调用顺序按照它们被继承时声明的基类名顺序执行。

（2)调用内嵌对象构造函数，调用次序按各个对象在派生类内声明的顺序

（3）执行派生类构造函数体中的内容

派生类析构函数执行的顺序【与构造函数相反】

（1）执行派生类析构函数

（2）执行内嵌对象的析构函数

（3）执行基类的析构函数

p250 参考例11-3

#include<iostream>
#include<cstring>
using namespace std;
class Person
{
    cahr Name[10];             //姓名
    int Age；
public:
    Person(char*name,int age)
    {
        strcpy(Name,name);
        Age=age;
        cout<<"constructor of person"<<Name<<endl;
        
    }
    ~Person()
    {
         cout<<"deconstructor of person"<<Name<<endl; 
    };

    class Student:public Person
    {
        char ClassName[10]；   //班级
        Person Monitor;  //班长   内嵌对象
    public:
    Student(char*name,int age,char *classname,char *name1,int age1):Person(name,age),Monitor(name1,age1)
    {
          strcpy(ClassName,classname);
          cout<<"constructor of Student"<<endl;
 
    }
    ~Student()
    {
        cout<<"deconstructor of Student"<<endl;
    }
};
    int main()
    {
        Student stu("张弓长"，18，"计算机51"，"李木子"，20)；
        return 0；
    }

5.编程题：由一个圆类派生圆柱类，圆由半径，构造函数，面积函数圆柱由高，构造函数，体积函数

#include<iostream>
#include<cmath>
using namespace std;
const double PI=3.1415926;
class Circle
{
protected:
    double c_r;
public:
    Circle(double r)
    {
        c_r=r;
    }
};
 
class Circular:public Circle
{
    double c_h;
public:
    Circular(double r,double h):Circle(r)
    {
        c_h=h;
    }
    double GetCircular_t()
    {
        return PI*c_r*c_r*c_h;
    }
	 double GetCircular_b()
    {
        return (2*PI*c_r*c_h)+(2*PI*c_r*c_r);
    }
    void ShowCircular()
    {
        cout<<"圆柱体的体积 ="<<GetCircular_t()<<endl;
		 cout<<"圆柱体的表面积 ="<<GetCircular_b()<<endl;
    }
};
 
int main()
{
    Circular b(10,10);
    b.ShowCircular();
    return 0;
}

第十二章

1.多态性的两种不同形式：编译时多态性与运行时多态性P265

2.虚函数

关键字 virtual 格式：

virtual 函数返回类型 函数名（） {函数体}

定义p269

实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数

3.

3.1纯虚函数的定义

基类中的虚函数是为了派生类中的使用而声明定义的，其在基类中没有任何意义。此类函数我们叫做纯虚函数，不需要写成空函数的形式，只需要声明成：

virtual 函数类型 函数名（形参表列）=0;

注意：纯虚函数没有函数体；

最后面的“=0“并不代表函数返回值为0，只是形式上的作用，告诉编译系统”这是纯虚函数”；

这是一个声明语句，最后应有分号。

纯虚函数只有函数的名字但不具备函数的功能，不能被调用。在派生类中对此函数提供定义后，才能具备函数的功能，可以被调用。

3.2 抽象类的概念p272

在面向对象的编程过程中，有些类的创建是毫无意义的，它的概念是抽象的，比如动物，电器，人这样类，比如到商店给店员说我要买一台电器。编程过程中可以将这些类设置为抽象类，以防止它们创建对象。

只要一个类中出现纯虚函数，那么这个类就是抽象类。

Class Animal{

         Public:

virtual void show() = 0;//纯虚函数的表达

};

抽象类除了不能实例化之外，和其他类没有任何区别。

4.

C++提供的两种重载方式为函数重载和运算符重载

不适合重载的运算符是那五个p275

. （成员访问运算符）

.* （成员指针访问运算符）

:: （域运算符）

sizeof （长度运算符）

?: （条件运算符）

5.常成员函数p277

用const修饰的声明声明成员函数称为常成员函数

声明：<类型标志符>函数名（参数表）const；

说明：

1. const是函数类型的一部分，在实现部分也要带该关键字。

2. const关键字可以用于对重载函数的区分。

3. 常成员函数不能更新任何数据成员，也不能调用该类中没有用const修饰的成员函数，只能调用常成员函数和常数据成员。

第十三章

1.函数模板的定义及使用p291 函数模板：是一种抽象通用的函数，用它可生成一批具体的函数。这些由函数模板实例化生成的具体函数称为模板函数。

template<typename T>
<类型><函数名>(<参数表>)
{
···
    }

2.友元函数p297

2.1定义

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

2.2关键字 friend

使用友元函数声明的一般形式：

friend <返回类型> <函数名> (<参数列表>);

2.3使用友元函数注意的要点：

1. 类中通过使用关键字friend 来修饰友元函数，但该函数并不是类的成员函数，其声明可以放在类的私有部分，也可放在共有部分。友元函数的定义在类体外实现，不需要加类限定。
2. 一个类中的成员函数可以是另外一个类的友元函数，而且一个函数可以是多个类友元函数。
3. 友元函数可以访问类中的私有成员和其他数据，但是访问不可直接使用数据成员，需要通过对对象进行引用。
4. 友元函数在调用上同一般函数一样，不必通过对对象进行引用。