C++与C语言的区别

C++和C有两大区别：

（1）设计思想不同

（2）语法规范不同

一、面向过程的语言

1.自顶向下的设计思想

将大程序分解为小程序，如果分解后的程序仍然过大，继续分解

2.结构化编程反映了过程性思想

将问题分步解决，根据问题的操作思想解决问题

3.尽管提高了清晰性、可读性，但还是有不少缺点的

程序的模块化仍然会导致混乱，相似的问题需要不同的代码实现，给代码维护带来困难

二、面向对象的语言

1.用客观世界中描述事物的方法描述一个程序要解决的问题。

2.引入对象和类的概念

对象

属性

方法

3.引用继承的概念

4.引用多态的概念

多态是指在基类（父类）中定义的属性或行为，被派生类（子类）继承后，可以具有不同的数据类型或表现出不同的行为。

三、C和C++中的函数

1.函数原型声明中都可以省略参数名称，只保留类型名称

2.空参数和可变参数

例如函数fun()

C++中表示没有参数，而C语言中表示参数不确定，表示没有参数是：fun(void)

可变参数（二者一样）

int fun(int a, ...) 参数的类型与个数都不确定

3.返回值

C中声明函数可以不写返回值类型，默认为int

main()

{

}

C++声明函数必须有返回值类型，如果没有返回值类型，则用void声明。

四、其他区别

1.true和false【bool型数据】

在C语言中两者都不是关键字，非零即true

在C++中是关键字，但不能用以下方式比较

if ( a == true){...}

因此，尽管C++拥有布尔型变量，但由于与C语言兼容，仍然不能直接对一个布尔型变量做对比操作。

2.作用域

C语言强制一个函数中所有变量在函数开始时就要全部定义，变量的作用域就是整个函数

C++，可以在任意位置定义变量

3.C++中增加了引用类型

主要应用在参数的传递过程中

引用只能初始化，不可另外赋值

void类型没有引用

4.register关键字的变化

register关键字请求“编译器”将局部变量存储于寄存器中

C语言中无法取得register变量地址，C++中可以取得register变量的地址

在C++中依然支持register关键字

C++编译器有自己的优化方式，不使用register也可能做优化

C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。

早期C语言编译器不会对代码进行优化，因此register变量是一个很好的补充。

5.全局变量的定义

在C语言中，重复定义多个同名的全局变量是合法的

在C++中，不允许定义多个同名的全局变量

C语言中多个同名的全局变量最终会被链接到全局数据区的同一个地址空间上。

C++直接拒绝这种二义性的做法。

6.对const常量的处理

当碰见常量声明时在符号表中放入常量

编译过程中若发现使用常量则直接以符号表中的值替换

编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间

注意：

C++编译器虽然可能为const常量分配空间，但不会使用其存储空间中的值

C语言中const变量是只读变量，有自己的存储空间

C++中的const常量

可能分配存储空间

当const常量为全局，并且需要在其它文件中使用

当使用&操作符取const常量的地址

#include ...

int main(int argc, char *argv[])

{

const int c = 0;

int *p = (int*)&c;

*p = 5;

printf("c = %d\n",c);

return 0;

}

以上代码在C和C++环境中输出的结果不同

C++中的const常量类似于宏定义

const int c = 5; ≈ #define c 5

#include ...

int main(int argc, char *argv[])

{

const int a = 1;

const int b = 2;

int array[a + b] = {0};

int i = 0;

for(i=0; i

{

printf("array[%d] = %d\n", i, array[i]);

}

printf("Press enter to continue ...");

getchar();

return 0;

}

C++中的const常量在与宏定义不同

const常量是由编译器处理的，提供类型检查和作用域检查

宏定义由预处理器处理，单纯的文本替换

#include ...

void f()

{

#define a 3

const int b = 4;

}

void g()

{

printf("a = %d\n", a);

//printf("b = %d\n", b);

}

int main(int argc, char *argv[])

{

f();

g();

printf("Press enter to continue ...");

getchar();

return 0;

}

7.struct类型的加强

C语言的struct定义了一组变量的集合，C编译器并不认为这是一种新的类型

C++中的struct是一个新类型的定义声明

8.变量和函数的类型

C++中所有的变量和函数都必须有类型

C语言中的默认类型在C++中是不合法的

在C语言中

int f()；表示返回值为int，接受任意参数的函数

int f(void)；表示返回值为int的无参函数

在C++中

int f();和int f(void)具有相同的意义，都表示返回值为int的无参函数

9.C++的布尔类型

C++在C语言的基本类型系统之上增加了bool

C++中的bool可取的值只有true和false

理论上bool只占用一个字节，

如果多个bool变量定义在一起，可能会各占一个bit，这取决于编译器的实现

true代表真值，编译器内部用1来表示

false代表非真值，编译器内部用0来表示

bool类型只有true（非0）和false（0）两个值

C++编译器会在赋值时将非0值转换为true，0值转换为false

常量与变量相关

const_cast

1.用来把const变量转换成一个非const变量

2.把volatile变量转换成一个非volatile变量

const int i = 0;

int *p = const_cast(&i);

C++流对象

1。需要包含头文件

2。输出流

cout

cout是输出流对象，endl是换行符

指定输出项占用的宽度

int i=6;

int j=7;

cout

______6_______7

cout.width(4);

cout.width(10);

3。填充

cout.width(10);

cout.fill('*');

cout

输出八、十六进制数和科学表示法的实数

float x=5.146,y=290;

cout.setf(ios::scientific,ios::floatfield);

//表明浮点数用科学表示法输出

coutcout

system("pause");

4。将数字转换成相应的数字输出,输出八、十六进制数和科学表示法的实数

注：要包含头文件 #include

coutcoutcout

hex(cout);

cout

dec(cout);

cout

oct(cout);

cout

说明：setw()只对当前的输出项有效。

cout指明一种数制输出后，对以后的输出一直有效，直到设置新的输入进制数。实数设置为科学计数法输出时也一样。

5。输入流

格式：cin>>变量1>>变量2……

int a,b;

cin>>a>>b;

float c,d;

cin>>c>>d;

char ch;

cin>>ch;

以上不能将空格和回车赋给变量

char c,d;

cin.get(c);

cin.get(d);

以上能将空格和回车赋给变量

输入十六进制或八进制数据

int i,j,k,m;

cin>>hex>>i;

cin>>oct>>j;

cin>>k;

cin>>dec>>m;

说明：缺省情况下，系统约定输入的整型数是十进制数据，若要其他进制数，在cin中要指明相应类型

hex为16进制，oct为八进制，dec为十进制

8进制16进制的输入，只适于整型变量，不适用于字符类型的变量。

cin指明使用的数制输入后，则一直有效，直到再次更改

高层输入输出流

printf, scanf, sprintf,sscanf

sscanf

char buf[512] = {0};

将指定的字符串输入到目标字符串:

sscanf("12345","%s",buf);

取出仅包含指定字符集的字符串:

sscanf("12345abc","%*d%s",buf);

取出指定长度的字符串：

sscanf("123456","%4s",buf);

取出指定字符为止的字符串：

sscanf("123456 abcdefg","%[^'b']",buf);

取出以指定字符集为止的字符串：

sscanf("12345678abcdefghijkABCDEFG","%[1-9a-z]",buf);

动态分配内存

new运算符

使用new动态分配内存

类型名 *指针变量 = new 类型名;

int *pNum = new int;

使用delete释放动态申请的内存。

delete 指针;

delete pNum; //释放内存块，并不删除指针变量本身

使用new申请动态数组

类型名 *指针变量名 = new 类型名[元素个数];

不要使用或释放已经释放的内存块

释放动态分配的数组内存时，应使用以下格式

delete [] 数组名字。

引用是变量的别名，只能初始化，不能被另外赋值，不另外占用内存

引用的使用限制

不能建立数组的别名

不能声明一个引用的引用

不能声明一个指向引用的指针

引用的语法：Type& name = var;

const引用

const Type& name = var;

让变量拥有只读属性

引用在C++中的内部实现是一个常指针

Type& name Type* const name

C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。

void swap(int& a, int& b)

{

int temp = a;

a = b;

b = temp;

}

int x = 66;

int y = 88;

swap(x, y);

隐含着 int& a = x; int& b = y;