[导读]关注「Linux大陆」，一起进步！链接：https://www.cnblogs.com/whale90830/p/10488595.html由C到COOP第一课C语言的局限C的特点C的程序特征C程序的结构特性C程序的编辑、编译和运行⭐C对C的补充C的特点C继承了C的优点，并有自己...

由C到C

OOP第一课

C语言的局限
C 的特点
C 的程序特征
C 程序的结构特性
C 程序的编辑、编译和运行
⭐C 对C的补充

C 的特点

C 继承了C的优点，并有自己的特点，主要有：

1、全面兼容C，C的许多代码不经修改就可以为Cpp所用，用C编写的库函数和实用软件可以用于Cpp。

2、用C 编写的程序可读性更好，代码结构更为合理，可直接在程序中映射问题空间结构。

3、生成代码的质量高，运行效率高。

4、从开发时间、费用到形成软件的可重用性、可扩充性、可维护性和可靠性等方面有了很大提高，使得大中型的程序开发项目变得容易得多。

5、支持面向对象的机制，可方便的构造出模拟现实问题的实体和操作。

C 的程序特征

例1.1 输出一行字符：“This is a C program.”。

程序如下：

#include //包含头文件iostream
using namespace std; //使用命名空间std
int main( )
{
cout<<″This is a C program.″;
return 0;
}

在运行时会在屏幕上输出以下一行信息：

This is a C program.

用main代表“主函数”的名字。每一个C 程序都必须有一个 main 函数。main前面的int的作用是声明函数的类型为整型。程序第6行的作用是向操作系统返回一个零值。如果程序不能正常执行，则会自动向操作系统返回一个非零值，一般为-1。
函数体是由大括号{}括起来的。本例中主函数内只有一个以cout开头的语句。注意C 所有语句最后都应当有一个分号。
再看程序的第1行“#include
”，这不是Cpp的语句，而是Cpp的一个预处理命令，它以“#”开头以与Cpp语句相区别，行的末尾没有分号。
#include是一个“包含命令”，它的作用是将文件iostream的内容包含到该命令所在的程序文件中，代替该命令行。文件iostream的作用是向程序提供输入或输出时所需要的一些信息。
iostream是i-o-stream3个词的组合，从它的形式就可以知道它代表“输入输出流”的意思，由于这类文件都放在程序单元的开头，所以称为“头文件” (head file)。在程序进行编译时，先对所有的预处理命令进行处理，将头文件的具体内容代替#include命令行，然后再对该程序单元进行整体编译。
程序的第2行“using namespace std;”的意思是“使用命名空间std”。Cpp标准库中的类和函数是在命名空间std中声明的，因此程序中如果需要用到Cpp标准库(此时就需要用#include命令行)，就需要用“using namespace std;”作声明，表示要用到命名空间std中的内容。
在初学C 时，对本程序中的第1,2行可以不必深究，只需知道：如果程序有输入或输出时，必须使用“#include
”命令以提供必要的信息，同时要用“using namespace std;”，使程序能够使用这些信息，否则程序编译时将出错。

例1.2 求a和b两个数之和

// 求两数之和 (本行是注释行)
#include //预处理命令
using namespace std; //使用命名空间std
int main( ) //主函数首部
{ //函数体开始
int a,b,sum; //定义变量
cin>>a>>b; //输入语句
sum=a b; //赋值语句
cout<<″a b=″<endl; //输出语句
return 0; //如程序正常结束，向操作系统返回一个零值
} //函数结束

本程序的作用是求两个整数a和b之和sum。

第1行“//求两数之和”是一个注释行，Cpp规定在一行中如果出现“//” ，则从它开始到本行末尾之间的全部内容都作为注释。

例1.3 给两个数x和y，求两数中的大者

#include //预处理命令
using namespace std;
int max(int x,int y) //定义max函数，函数值为整型，形式参数x， y为整型
{ //max函数体开始
int z; //变量声明，定义本函数中用到的变量z为整型
if(x>y) z=x; //if语句，如果x>y，则将x的值赋给z
else z=y; //否则，将y的值赋给z
return(z); //将z的值返回，通过max带回调用处
} //max函数结束
int main( ) //主函数
{ //主函数体开始
int a,b,m; //变量声明
cin>>a>>b; //输入变量a和b的值
m=max(a,b); //调用max函数，将得到的值赋给m
cout<<″max=″<//输出大数m的值
return 0; //如程序正常结束，向操作系统返回一个零值
} //主函数结束

本程序包括两个函数:主函数main和被调用的函数max。

程序运行情况如下:

18 25 ↙ (输入18和25给a和b)
max=25 (输出m的值)

注意输入的两个数据间用一个或多个空格间隔，不能以逗号或其他符号间隔。

在上面的程序中，max函数出现在main函数之前，因此在main函数中调用max函数时，编译系统能识别max是已定义的函数名。如果把两个函数的位置对换一下，即先写main函数，后写max函数，这时在编译main函数遇到max时，编译系统无法知道max代表什么含义，因而无法编译，按出错处理。

为了解决这个问题，在主函数中需要对被调用函数作声明。上面的程序可以改写如下：

#include
using namespace std;
int max(int x,int y); //对max函数作声明
int main( )
{
int a,b,c;
cin>>a>>b;
c=max(a,b); //调用max函数例1.3 给两个数x和y，求两数中的大者。
cout<<″max=″<endl;
return 0;
}
int max(int x,int y) //定义max函数
{
int z;
if(x>y) z=x;
else z=y;
return(z);
}

只要在被调用函数的首部的末尾加一个分号，就成为对该函数的函数声明。函数声明的位置应当在函数调用之前。

C 程序的结构特性

一个面向对象的C 程序一般由类的声明和类的使用两大部分组成。

类的使用部分一般由主函数及有关子函数组成。

典型的C 程序结构

#include
//类的声明部分
class A{
int x,y,z;
……
fun( ){……}
……
};
//类的使用部分
int main()
{
A a;
……
a.fun();
return 0;
}

在C 程序中，程序设计始终围绕“类”展开。通过声明类，构建了程序所要完成的功能，体现了面向对象程序设计的思想。

C＋＋程序的编辑、编译和运行

C 源程序文件的扩展名为.CPP

可以用多种编译器编辑、编译和运行

C 对C的补充

1、注释与续行

注释符：“/*”和“*/” 或“//” 。

Cpp新增了注释语句，它由“//”开始，到行尾结束。

例如：

X = y z; /*This is a comment */
X = y z; //This is a comment

续行符：“\”（反斜杠）。作用是当一个语句太长时可以用该符号把它分段写在几行中。
例：

cout << ‘\n’ << “x=” << x << “y=” << y << “z=” << z\
<< “u=” << u << “v\
=” << v << “w=” << w << endl;

2、输入输出流

C中I/O操作出现的问题：

int i;
float f;
scanf(“%f”,i);
printf( “%d”,d);

Cpp中使用更安全更方便的方法：

int i;
float f;
cin >> i;
cout << f;

cout和cin分别是C 的标准输出流和输入流。Cpp支持重定向，但一般cout指的是屏幕， cin指的是键盘。

操作符“<<”和“>>”除了具有C语言中定义的左移和右移的功能外，在这里符号“<<”是把右方的参数写到标准输出流cout中；相反，符号“>>”则是将标准输入流的数据赋给右方的变量。

例1.4 一个完整的C 程序

#include
int main()
{
char name[20];
cout << "Hello， your name： ";
cin >> name;
cout << name;
return 0;
}

注意：

程序中必须包含头文件iostream.h
cin和>>,cout和<<配套使用
cin可以输入多个数据,但要用空白符隔开（tab，空格，回车）

如：cin >> a >> b >> c;

换行符：‘\n’或endl

如：cout << “x=” << x << endl; cout << “x=” << x << ‘\n’;

使用cout和cin时，也可以对输入和输出的格式进行控制，比如可用不同的进制方式显示数据，只要设置转换基数的操作符dec、hex和oct即可。

例1.5 操作符dec、 hex和oct的使用

#include
void main()
{
int x=25;
cout << hex << x << ' ' << dec << x << ' ' << oct << x << '\n';
}

输出结果为：19 25 31

3、灵活的变量说明

定义变量的位置

在程序中的不同位置采用不同的变量定义方式，决定了该变量具有不同的特点。变量的定义一般可有以下三种位置：

(1) 在函数体内部

在函数体内部定义的变量称为局部变量，这种局部变量只在进入定义它的函数体时起作用，离开该函数体后该变量就消失（被释放），即不再起作用。因此，不同函数体内部可以定义相同名称的变量，而互不干扰。

(2) 形式参数

当定义一个有参函数时，函数名后面括号内的变量，统称为形式参数。

(3) 全局变量

在所有函数体外部定义的变量，其作用范围是整个程序，并在整个程序运行期间有效。

在C语言中，全局变量声明必须在任何函数之前，局部变量必须集中在可执行语句之前。
Cpp中的变量声明非常灵活，它允许变量声明与可执行语句在程序中交替出现。

例如

f( )
{
int i;
i=10;
int j;
j=25;
// …
}
float fun(int x,int y)
{
for(int i=0;i<10;i )
{
int sum=0;
sum=sum i;
cout<<“sum=”< }
int z=0;
z=x y;
}

4、结构、联合和枚举名

在C 中，结构名、联合名、枚举名都是类型名。在定义变量时，不必在结构名、联合名或枚举名前冠以struct、union或enum。

例如：

enum boole{FALSE,TRUE};
struct string{
char *string;
int length;
};
union number{
int i;
float f;
};

在传统的C中，定义变量时，必须写成：

enum boole done;
struct string str;
union number x;

但是，在C 中，可以说明为：

boole done;
string str;
number x;

5、函数原型

C语言建议编程者为程序中的每一个函数建立原型，而Cpp要求为每一个函数建立原型，以说明函数的名称、参数类型与个数，以及函数返回值的类型。

其主要目的是让C 编译程序进行类型检查，即形参与实参的类型匹配检查，以及返回值是否与原型相符，以维护程序的正确性。

例如

int sum(int a,int b); //是函数sum的原型

函数原型语法的一般形式为：返回类型函数名（参数表）；
函数原型是一条语句，它必须以分号结束。

例1.6 函数原型的说明

#include
void write(char *s);
void main()
{write("Hello,world!");}
void write(char *s)
{cout<

在程序中，要求一个函数的原型出现在该函数的调用语句之前。

说明：

函数原型的参数表中可不包含参数的名字，而只包含它们的类型。例如：long Area(int ,int);
函数定义由函数首部和函数体构成。函数首部和函数原型基本一样，但函数首部中的参数必须给出名字而且不包含结尾的分号。
Cpp的参数说明必须放在函数说明后的括号内，不可将函数参数说明放在函数首部和函数体之间。这种方法只在C中成立。
主函数不必进行原型说明，因为它被看成自动说明原型的函数。
原型说明中没有指定返回类型的函数(包括主函数main)，Cpp默认该函数的返回类型是int
如果一个函数没有返回值，则必须在函数原型中注明返回类型为void，主函数类似处理。
如果函数原型中未注明参数，Cpp假定该函数的参数表为空(void)。

6、const修饰符

在C中，习惯使用#define定义常量。

一般格式： #define 宏名常数

如

#define PI 3.14
…………
s = 2 * PI * r;
…………

C 利用const定义正规常数

一般格式：const 数据类型标识符常数名=常量值；

采用这种方式定义的常量是类型化的，它有地址，可以用指针指向这个值，但不能修改它。

说明:

1、const必须放在被修饰类型符和类型名前面

2、数据类型是一个可选项，用来指定常数值的数据类型，如果省略了该数据类型，那么编译程序认为它是 int 类型。

如：const int a=10; 表示定义了一个初始值为10的整型常量，它在程序中不可改变，但可用于表达式的计算中。

例2.6 #define的不安全性

#include "iostream.h"
main()
{
int a=1;
#define T1 a a
#define T2 T1-T1
cout<<"T2 is "<endl;
return 0;
}

但实际的输出是：T2 is 2

const作用与#define相似，但消除了#define的不安全性。

如果用const取代了两个#define,就不会引起这个错误。

#include
int main()
{
int a=1;
const T1=a a;
const T2=T1-T1;
cout <<"T2 is"<endl;
return 0;
}

const可以与指针一起使用

（1）指向常量的指针：一个指向常量的指针变量。

例如：

const char* pc=“abcd”; //声明指向常量的指针
pc[3]=‘x’; //错误
pc=“efgh”; //允许

（2）常指针：把指针本身，而不是它指向的对象声明为常量。

例如：

char* const pc=“abcd”; //常指针
pc[3]=‘x’; //合法
pc=“efgh”; //出错

创建一个常指针，就是创建一个不能移动的固定指针，但是它所指的数据可以改变。例如:

（3）指向常量的常指针：这个指针本身不能改变，它所指向的值也不能改变。

要声明一个指向常量的常指针，二者都要声明为const。

例如：

const char* const pc=“abcd”; //指向常量的常指针
pc[3]=‘x’; //出错
pc=“efgh”; //出错

这个语句的含义是：声明了一个名为pc的指针变量，它是一个指向字符型常量的常指针，用“abcd”的地址初始化该指针。

说明

(1). 如果用const定义的是一个整型常量，关键词int可以省略。所以下面的两语句是等价的

const int bufsize=200;

const bufsize=200;
(2). 常量一旦被建立，在程序的任何地方都不能再更改。
(3). 与#define定义的常量有所不同，const定义的常量可以有自己的数据类型，这样C 的编译程序可以进行更加严格的类型检查，具有良好的编译时的检测性。
(4). 函数参数也可以用const说明，用于保证实参在该函数内部不被改动，大多数C 编译器能对具有const参数的函数进行更好的代码优化。