学习C++第三课

记录学习C++的第三课，只希望考试不要太难

---

一、面向过程的程序设计

1.1 算法的概念

一个基于过程的程序应该包括一下两个方面内容：

• ①对数据的描述：在程序中要指定数据的类型和数据的组织形式，即数据结构
• ②对操作的描述：即操作步骤，也就是算法

程序 = 算法 + 数据结构
算法是处理问题的一系列的步骤。算法必须具体地指出在执行时每一步应当“怎么做”

1.2 算法的表示

一、自然语言
二、流程图
三、伪代码
四、用计算机语言表示算法

1.3 C++的程序结构和C++语句

(1) 预处理指令：如#include指令和#define指令
(2) 全局声明：在函数外对数据类型、函数以及变量的声明和定义
(3) 函数：包括函数首部和函数体，在函数体中可以包含声明语句和执行语句

#include  //预处理指令
using namespace std; //在函数之外的全局声明
int a = 2; //在函数之外的全局声明
int main() //函数首部
{
	float b; //函数内的声明
	b = 4.5; //执行语句
	cout<<a<<b; //执行语句
	return 0;//执行语句
}
1
2
3
4
5
6
7
8
9
10

如果一个变量在函数之外进行声明，此变量是全局变量

二、C++的输入和输出

C++的输出和输入是用“流”（stream）方式实现的。“流”指的是来自设备或传输给设备的一个数据

• cout：输出流对象的名字
• cin：输入流对象的名字

2.1 输入流与输出流的基本操作

• 一个cout语句可以分写成若干行。如：
  cout <<“This is a simple C++ program.”<
• 也可以写成：
  cout<<“This is” //注意行末尾无分号
  <<“a C++”
  <<“program.”
  <
• 也可以写成多个cout语句，即：
  cout << “This is”; //语句末尾有分号
  cout<<“a C++”;
  cout << “program”;
  cout <

注意： 不能用一个插入运算符“<<”插入多个输出项：

• cout<
• cout<

在用cout输出时，用户不必通知计算机按何种类型输出，系统会自动判别输出数据的类型，使输出的数据按相应的类型输出。

• 如：已定义a为int型，b为float型，c为char型，则
  cout< 会以下面的形式输出：
  4 345.789 a

在定义流对象时，系统会在内存中开辟一段缓冲区，用来暂存输入输出流的数据。
输入流的用法和输出流基本相似。

• 输入输出时有一些特殊的要求，如：在输出实数时规定字段宽度；只保留两位小数；数据向左或向右对齐等
• 如果使用了控制符，在程序单位的开头除了要加iostream头文件外，还要加iomanip头文件。

三、函数

函数的分类

• 系统函数，即库函数
• 用户自己定义的函数
• 无参函数
• 有参函数

3.1 内联函数

调用函数时需要一定的时间和空间的开销

• C++提供一种提高效率的方法，即在编译时将所调用函数的代码直接嵌入到主调函数中，而不是将流程转出去。
• 这种嵌入到主调函数中的函数称为内置函数(inline function)，又称内嵌函数。在有些书中把它译成内联函数。
• 指定内置函数的方法很简单，只需在函数首行的左端加一个关键字inline即可。

#include 
using namespace std;
inline int max(int,int, int);       //声明函数，注意左端有inline
int main( )
{int i=10,j=20,k=30,m;
 m=max(i,j,k);
 cout<<″max=″<<m<<endl;
 return 0;
}
inline int max(int a,int b,int c)       //定义max为内置函数
{if(b>a) a=b;                           //求a,b,c中的最大者
 if(c>a) a=c;
 return a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 可以在声明函数和定义函数时同时写inline，也可以只在函数声明时加inline。
• 内置函数中不能包括复杂的控制语句，如循环语句和switch语句。
• 对函数作inline声明，是建议性的，而不是指令性的。
• 只有那些规模较小而又被频繁调用的简单函数，才适合于声明为inline函数。

3.2 函数的重载

有时要实现的是同一类的功能，只是细节不同：例如从3个数中找出其中的最大者，而每次求最大数时数据的类型不同，可能是3个整数、3个双精度数或3个长整数。程序设计者往往会分别设计出3个不同名的函数，其函数原型为

• int max1(int a，int b, int c); //求3个整数中的最大者

• double max2(double a，double b，double c); //求3个双精度数中最大者

• long max3(long a，long b，long c); //求3个长整数中的最大者

• C++允许用同一函数名定义多个函数，这些函数的参数个数和参数类型不同。这就是函数的重载(function overloading)。即对一个函数名重新赋予它新的含义，使一个函数名可以多用。

#include 
using namespace std;
int main( )
{      int max(int a,int b,int c);                //函数声明
double max(double a,double b,double c);    //函数声明
long max(long a,long b,long c);            //函数声明
 int i1,i2,i3,i;                            
 cin>>i1>>i2>>i3;                         //输入3个整数
 i=max(i1,i2,i3);                         //求3个整数中的最大者
 cout<<″i_max=″<<i<<endl;
 double d1,d2,d3,d;    
 cin>>d1>>d2>>d3;                         //输入3个双精度数
 d=max(d1,d2,d3);                         //求3个双精度数中的最大者
 cout<<″d_max=″<<d<<endl;
 long g1,g2,g3,g;
 cin>>g1>>g2>>g3;                         //输入3个长整数
  g=max(g1,g2,g3);                         //求3个长整数中的最大者
 cout<<″g_max=″<<g<<endl;
}
int max(int a,int b,int c)            //定义求3个整数中的最大者的函数
{if(b>a) a=b;
 if(c>a) a=c;
 return a;
} 
//定义求3个双精度数中的最大者的函数
double max(double a,double b,double c)
{if(b>a) a=b;
 if(c>a) a=c;
 return a;
}
//定义求3个长整数中的最大者的函数
long max(long a,long b,long c)
{if(b>a) a=b;
 if(c>a) a=c;
 return a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

系统会根据调用函数时给出的信息去找与之匹配的函数：实参的类型

重载函数除了允许参数类型不同以外，还允许参数的个数不同

#include 
using namespace std;
int main( )
{int max(int a,int b,int c);              //函数声明
 int max(int a,int b);                    //函数声明
 int a=8,b=-12,c=27;
 cout<<″max(a,b,c)=″<<max(a,b,c)<<endl;   //输出3个整数中的最大者
 cout<<″max(a,b)=″<<max(a,b)<<endl;       //输出两个整数中的最大者
}
int max(int a,int b,int c)        //此max函数的作用是求3个整数中的最大者
{if(b>a) a=b;
if(c>a) a=c;
 return a;
}
//此max函数的作用是求两个整数中的最大者
int max(int a,int b)
{if(a>b) return a;
else return b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 重载函数的参数个数、参数类型或参数顺序，这3者中必须至少有一种不同，函数返回值类型可以相同也可以不同。
• 在使用重载函数时，同名函数的功能应当相同或相近，不要用同一函数名去实现完全不相干的功能，虽然程序也能运行，但可读性不好

3.2 函数模板

• C++提供了函数模板(function template).
• 建立一个通用函数，其函数类型和形参类型不具体指定用一个虚拟的类型来代表，这个通用函数就称为函数模板
• 凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可
• 在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

#include 
using namespace std;
template  <typename T>        //模板声明，其中T为类型参数
T max(T a,T b,T c)          //定义一个通用函数，用T作虚拟的类型名
{if(b>a) a=b;
 if(c>a) a=c;
 return a;
}
int main( )
{int i1=185,i2=-76,i3=567,i;
 double d1=56.87,d2=90.23,d3=-3214.78,d;
 long g1=67854,g2=-912456,g3=673456,g;
i=max(i1,i2,i3);          //调用模板函数，此时T被int取代
 d=max(d1,d2,d3);    //调用模板函数，此时T被double取代
g=max(g1,g2,g3);      //调用模板函数，此时T被long取代
 cout<<″i_max=″<<i<<endl;
 cout<<″f_max=″<<f<<endl;
 cout<<″g_max=″<<g<<endl;
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

定义函数模板的一般形式为

• template < typename T>

• template < class T>

• T max(T a,T b,T c) //定义一个通用函数，用T作虚拟的类型名

• T：类型参数，实际上是一个虚拟的类型名；

• class 和typename的作用相同，都表示“类型名”，可互换。

• 类型参数可以不只一个，可以根据需要确定个数。如
  template

• 只适用于函数的参数个数相同而类型不同，且函数体相同的情况，如果参数的个数不同，则不能用函数模板。

3.3 函数模板

有时多次调用同一函数时用同样的实参，C++提供简单的处理办法，给形参一个默认值

• float area(float r=6.5);

实参与形参的结合是从左至右顺序进行的。因此指定默认值的参数必须放在形参表列中的最右端，否则出错

• void f1(float a，int b=0，int c，char d=′a′); //不正确
• void f2(float a，int c，int b=0, char d=′a′); //正确

#include 
using namespace std;
int main( )
{int max(int a, int b, int c=0);//函数声明,形参c有默认值
int a,b,c;
 cin>>a>>b>>c;
 cout<<″max(a,b,c)=″<<max(a,b,c)<<endl;   //输出3个数中的最大者
 cout<<″max(a,b)=″<<max(a,b)<<endl;       //输出2个数中的最大者
 return 0;
}
int max(int a,int b,int c) //函数定义
{if(b>a) a=b;
 if(c>a) a=c;
 return a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

一个函数不能既作为重载函数，又作为有默认参数的函数

四、 C++处理字符串的方法——字符串类与字符串变量

• 用字符数组来存放字符串并不是最理想和最安全的方法。
• C++提供了一种新的数据类型——字符串类型(string类型)，在使用方法上，它和char、int类型一样，可以用来定义变量，这就是字符串变量——用一个名字代表一个字符序列。
• string并不是C++语言本身具有的基本类型，它是在C++标准库中声明的一个字符串类，用这种类可以定义对象。每一个字符串变量都是string类的一个对象

4.1 字符串变量的定义和引用

• 定义字符串变量要用类名string
• 应当注意： 要使用string类的功能时，必须在本文件的开头将C++标准库中的string头文件包含进来

4.2 字符串变量的运算

在以字符数组存放字符串时，字符串的运算要用字符串函数，如strcat(连接)、strcmp(比较)、strcpy(复制)
而对string类对象，可以不用这些函数，而直接用简单的运算符

• (1) 字符串复制用赋值号
• (2) 字符串连接用加号
• (3) 字符串比较直接用关系运算符

4.3 字符串数组

• 在一个字符串数组中包含若干个(现为5个)元素，每个元素相当于一个字符串变量。
• 并不要求每个字符串元素具有相同的长度。
• 在字符串数组的每一个元素中存放一个字符串，而不是一个字符，这是字符串数组与字符数组的区别。
• 每一个字符串元素中只包含字符串本身的字符而不包括′＼0′。
• 在字符串变量中存放的是字符串的指针(字符串的地址)