C到C++的过渡

C到C++的过渡

2022/2/26

c语言结构化程序设计面临的问题

·开发大型软件系统
·对大型软件系统的维护与升级
·数据与算法是分离的

##解决方法：数据类
数据类=数据+算法

##面向对象程序设计与c++语言
·面向对象程序设计
·从c语言到c++语言
c++是c的超集
·已继承标准c库
·c++标准库
头文件<stdio.h> substituted to
用cin/cout流对象代替scanf/printf等输入输出函数

C++语言对C语言语法的扩充

1.数据的输入与输出
2.变量初始化以及常变量
3.引用及函数间参数的引用传递
4.几种特殊形式的函数
5.命名空间
6.动态内存分配

数据的输入与输出

·C语言的输入与输出

• 使用输入输出函数的scanf，printf等
• 头文件是#include<stdio.h>

·C++语言的输入与输出

• 将提供输入数据的数据源称作输入数据流
• 将输出数据时的目的地称作输出数据流
• 输入数据流和输出数据流统称为输入/输出流

·标准输入/输出流

• 键盘（cin）、显示器（cout）
• 相关声明语句

#include<iostream>//标准输入or输出流的头文件
using namespace std;//声明命名空间std
int main(){
	double ctemp,fremp;
	cin>>ctemp;
	fremp=ctemp*1.8+32;
	cout<<"华氏温度="<<ftemp<<endl;
	return 0;
}

c++语法：标准输入语句

cin>>变量1>>变量2>>…>>变量n;

语法说明：

·cin表示键盘，借用右移运算符>>表示数据从键盘流向后面的变量；
·一条输入语句可以输入多个变量的数据，输入时用空格或者Tab隔开，
以回车键结束；
·键盘所输入数据的类型应该和变量的类型所匹配；
·执行该语句时，计算机将暂停程序的运行，等待用户从键盘输入
指定个数和类型的数据，然后将这些数据按位置次序赋值给相应的变量。

c++语法：标准输出语句

cout<<表达式1<<表达式2<<…<<表达式n;
·cout表示显示器，<<表示数据从内存流向显示器；
·endl表示换行显示；
·一条输出语句可以同时输出多个表达式的结果；
·执行该语句时，计算机首先按从左到右的顺序逐个计算表达式的结果，
然后再按从左到右的顺序依次表示各表达式的结果，各显示结果之间没有
间隔。

C++对比C，输入输出的编写上简单了许多。

变量初始化以及常变量

·变量初始化

int x=10,y;//c风格
int x(10),y;//c++风格

·c语言中的符号常量
#define PI 3.14

·c++引入了常变量
const 数据类型 常变量名=初始值;
语法说明：

• 使用const关键字指定常变量；
• 定义常变量时必须初始化；
• 常变量的值不能改变，例如不能被再次赋值。

引用及函数间参数的引用传递

·访问变量内存单元
假设已定义变量 int x = 10

• 变量名访问：

 cout<<x;

• 指针访问：

int *p;
p=&x;
cout<<(*p);

• C++语言新增了引用访问

·引用：已有变量的别名

int &xa = x;
cout<<xa;

·直接访问：定义变量后，通过变量名访问内存单元
·间接访问：为变量定义引用，用引用名来访问内存单元

C++语法:定义引用变量

引用类型 &引用变量名 = 被引用变量名

语法说明:
·引用类型必须与被引用变量的类型一致
·引用变量名需符合标识符的命名规则
·定义变量语句中变量名前加一个&表示该变量为引用变量
·被引用变量必须是一个定义过的变量
·定义引用变量时必须初始化，引用变量只能引用一个变量，定义后不能再引用其它变量

int x;int &xa=x;
int x,&xa=x;//可在一条定义语句中完成
int x;int y,&xa=x;//一条定义变量语句可以既包括普通变量，又包括引用变量

函数间参数的传递

• 值传递
• 指针传递

举例 swap函数

#include<iostream>
using namespace std;

void swap(int &a,int &b)//引用传递：将形参定义成引用变量
{
	int t;
	t=a;
	a=b;
	b=t;
}
int main()
{
	cout<<"Exchange x and y"<<endl;
	int x = 5,y = 10;
	cout<<x<<","<<y<<endl;
	swap(x,y);
	cout<<x<<","<<y<<endl;
	return 0;
}

引用传递的特点

• 引用传递将被调函数的形参定义成主调函数中实参变量的引用，被调函数通过该引用间接访问主调函数中的变量。

• 被调函数修改形参实际上修改的是对应的实参。换句话说，主调函数可以通过引用将数据传给被调函数，被调函数也可以通过该引用修改实参的值将数据传回主调函数。引用传递是一种双向数据传递机制。

• 引用传递时，实参必须是变量。

• 引用传递的好处：一是形参直接引用实参，不需分配内存、传递数值，这样可以提高函数调用速度，降低内存占用；二是可以通过引用实现双向数据传递。

几种特殊形式的函数

• 带默认形参值的函数

定义函数或者声明函数原型时可以指定形式参数的默认值，这就是带默认形参值的函数。调用带默认形参值的函数时，如果给出实参值，则将实参值赋值给形参变量；如果没有，则将默认值赋值给形参变量。

语法细则：

• 带默认值的形参
• 在函数原型声明中指定默认值

void fun(int p = 10);//指定文件作用域的形参默认值为10

···
int main()
{
	fun();//显示10
	{
		void fun( int p =20);//指定块作用域形参默认值为20
		fun();//使用块作用域的默认值（局部优先）为20
	}
	return 0;
}
void fun(int p)//因为前面main之前的声明语句已经制定了文件作用域的默认值，此处不能再指定
{
	cout<<p<<endl;//显示形参p接收到的实参值
} 

• 带默认值的形参必须定义在形参列表的后面

void fun(int p1 = 10, int p2 = 20,int p3 = 30);//正确
void fun(int p1,int p2 = 20,int p3 = 30);//正确
void fun(int p1 = 10,int p2 =20, int p3);//错误

重载函数

• C语言中的函数不可以重名
• C++语言
  如果两个函数的形参个数不同，或者数据类型不同，那么这两个函数就可以重名。重名的函数被称为重载函数。
  举例：

int Max(int x,int y){return ((x>y)?x:y);}
double Max(double x,double y){return ((x>y)?x:y);}
int Max(int x,int y,int z)
{
int m;
m = (x>y)?x:y;
m = (m>z)?m:z;
return m;
}

cout<<Max(9,5);//自动调用int Max(int x,int y)
cout<<Max(9.0,5.0);//自动调用double Max(double x,double y)
cout<<Max(9,5,17);//自动调用int Max(int x,int y,int z)

内联函数

• 调用函数
  函数跳转和数据传递需要执行一些额外的操作。实现相同的功能，单一主函数程序比主函数+子函数程序程序的执行速度要快，即函数跳转会降低程序的执行效率。
• 内联函数
  内联函数是一种特殊的函数，它在保证开发效率的同时，不降低程序的执行效率。其原理是：编译源程序时将函数代码直接嵌入到每一个调用语句处，而在执行时不再进行函数跳转和数据传递。

例：一个兑换rmb的C++程序
#include <iostream>
using namespace std;
inline double Exchange (double amount,double rate = 6.1104)
{return amount/rate;}

int main(){
cout <<Exchange(500)<<endl;//显示500rmb兑换多少美元
cout <<Exchange(500,6.9698)<<endl;//显示500rmb兑换多少欧元
cout <<Exchange(500,9.7347)<<endl;//显示500rmb兑换多少英镑
cout <<Exchange(500,0.78817)<<endl;//显示500rmb兑换多少港币
return 0;
}

命名空间

• 命名空间
  · 在命名空间中定义函数和全局变量

namespace Tom 
{
	int x,y;
	void fun1(){······}
	void fun2(){······}
}

• 访问命名空间中的函数和全局变量

Tom::x = 10;Tom::y = 20;//访问全局变量
Tom::fun1();Tom::fun2();//调用函数

using Tom::x;//先单独声明各标识符的命名空间
using Tom::y;
using Tom::fun1;
using Tom::fun2;
x = 10;//再通过标识符访问。访问时可以省略命名空间
y = 20;
fun1();
fun2();

using namespace Tom;//先统一声明命名空间里的所有标识符
x = 10;y = 20;//再通过标识符访问。访问时可以省略命名空间
fun1();fun2();

动态内存分配

• C语言
  ·分配内存：malloc函数
  ·释放内存：free函数

• C++语言
  ·分配内存：new运算符
  ·释放内存：delete运算符

• 静态分配

int x;//定义一个int型变量x，定义时指定数据类型和变量名
      //计算机执行该语句将为变量x分配一个4字节的内存单元
x=10;//通过变量名x访问所分配的内存单元，向其中写入数据10
cout<<x;//通过变量名x访问所分配的内存单元

##C++语法：单个变量的动态分配和释放

指针变量名 = new数据类型（初始值）；
delete指针变量名；
语法说明：

• 数据类型指定动态分配变量的数据类型（用小括号括起来）,即变量的初始化。如果不需要初始化，“(初始值)”则可以省略；
• 计算机执行new运算符时将按照数据类型指定的字节数分配内存空间并初始化，然后返回所分配内存单元的首地址。应当通过赋值语句将该首地址保存到一个预先定义好的同类型指针变量中；
• 计算机执行delete运算符时将按照指针变量中的地址释放指定的内存单元

int *p;//为了动态分配一个int型变量，需预先定义好一个int型指针变量
p=new int;//使用new运算符动态分配一个int型变量，无变量名
          //将所分配内存单元的首地址赋值给指针变量p
*p=10;//通过指针变量p间接访问所分配的内存单元，向其中写入数据10
cout<<*p;//通过指针变量p间接访问所分配的内存单元
delete p;//内存使用完后，用delete运算符释放该内存空间

##C++语法：一维数组的动态分配与释放
指针变量名=new数据类型[整数表达式]；
delete[]指针变量名；
语法说明：

• 数据类型指定动态分配数组变量的数据类型
• 表达式指定一维数组的元素个数，用中括号[]括起来。表达式可以是单个常量、变量或者是一个整数表达式，其结果必须为正整数；
• 计算机执行new运算符时将按照数据类型和元素个数分配相应字节的内存空间，然后返回所分配内存单元的首地址。应当通过赋值语句将该首地址保存到一个预先定义好的同类型指针变量中。ps：动态分配的数组变量不可初始化；
• 计算机执行delete运算符时将按照指针变量中地址释放指定的内存单元，“[]”表示所释放的内存空间是一个数组，其中包含多个内存单元，应同时释放。

int *p=new int[5];//动态分配一个int型一维数组变量，包含5个数组元素
*(p+1)=10;//通过指针运算符访问第一个元素，向其中写入数据10
          //或通过下标运算符访问第一个元素：p[1]=10;
cout<<*(p+1);//通过指针运算符访问第一个元素，读出数据10并显示
             //或通过下标运算符访问第一个元素：cout<<p[1];
delete[]p;//内存使用完后，用delete运算符释放该数组变量所分配的内存空间

指针与数组

• 显示Fibonacci数列前n项的C++程序

#include<iostream>
using namespace std;

int main(){
	int N;//定义一个int型变量N
	cin>>N;//键盘输入要显示数列的前多少项

	int *p = new int[N];//动态创建包含N个元素的数组，用于保存数列的前N项
	p[0]=0;p[1]=1;//指定数列的前2项

	int n;//为循环语句定义好循环变量n
	for(n=2;n<N;n++)//使用循环结构计算出剩余的数列项
	p[n]=p[n-1]+p[n-2];//每一项＝前两项之和
	for(n=0;n<N;n++)//遍历显示数组
	{
	cout<<p[n]<<" ";
	if ((n+1)%5==0)
	cout<<endl;
	}
        delete[]p;//数组使用结束，动态释放其内存空间
	system("pause");
	return 0;
}