C和C++的区别:
- 标准输入输出
- 常量
- 引用问题
- 函数重载问题
- 函数形参和实参的问题
- 动态内存
下面将分别对以上区别作出阐述:
1 标准输入输出
//c语言 C++
#include<stdio.h> #include<iostream>
using namespace std;
int mian() int main()
{ {
int a; int a;
scanf("%d",&a); char c;
printf("%d",a); cin>>a>>c;//,(标准输入设备)与提取运算符>>一起使用
} cout<<a<<c;//(标准输出设备)与插入运算符<<一起使用
cout<<"a = "<<a<<"c = "<<c<<endl;//endl=\n
}
- 常量
C:
宏常量#define PI 3.14//在预编译时被替换
枚举常量enum{LEN1 = 10,LEN2 = 20}
枚举常量
枚举型是一个集合,集合中的元素(枚举成员)是一些命名的整型常量,元素之间用逗号,隔开。
枚举常量的定义格式:
enum 枚举名{枚举名 = 值,枚举名 = 值,枚举名 = 值…};
也可以不赋值,他默认会从0开始递增
enum 枚举名(枚举名,枚举名,枚举名,枚举名)
枚举常量可以把他理解成#define
每当定义一个枚举名 则 如同 #define 枚举名值
如果要从某个值开始递增,那么则可以在第一个枚举名赋值,随之会从第一个枚举名赋值的常量开始递增
enum 枚举名(枚举名 = 值,枚举名,枚举名,枚举名)
C++
常变量const int a = 10;//在编译时被替换,只有在C++搞得标准中使用,C的C89中没有const
结果为————:a=10 b=10 *p=100
从以上的程序中可以看出,常变量和宏有的一拼!!! 均在运行前的编译过程就被替换。
- C++有引用
引用的三个特点:
①没有空引用:
②没有引用的引用,引用不分级:int &c =a ; int &&x = c;没必要这样,因此不存在
③定义引用必须给予初始化,int &x; 不存在
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b =a;
int &c = a;//引用a就是c,c就是a
}
C语言需要传指针,并且解引用
C++实现交换函数:使用引用直接对实参进行交换
void Swap(int &a,int &b)
{
int tmp = a;
a = b;
b = tmp;
}
常引用
int a = 10;
int& b = a;
const int& c = a;
a += 10;
c += 10;
可以通过a改变自身的值,也可以通过b改变引用的值,但是不能通过c改变a的值,因为c是常引用,c只可读不可写(程序依次向下执行,权力收缩);
- 函数重载
- C++允许在同一作用域中声明几个类似的同名函数,这些同名函数的形参列表(参数个数,类型,顺序)必须不同,常用来处理实现功能类似数据类型不同的问题
C++能进行函数重载的根本原因:名字粉碎技术
可以了解C++函数编译时的修饰符规则
C语言是通过函数名称对函数进行区分的,产生命名冲突,不支持重载,编译方式:_函数名
C++支持函数重载
参数类型不同,参数个数不同,并且函数的返回值不能作为函数重载的依据。
所以C++函数重载的依据是:
-
函数形参的个数
-
函数形参的类型
-
形参的顺序
-
函数的返回值不能作为函数重载的依据,因为在函数调用过程中会产生二义性,编译器在编译时不会去判断函数的返回类型,函数只有调用后,编译器才会去验证返回类型,所以返回值不能作为函数重载的依据;
-
函数名相同,参数类型相同时,但参数个数不同时能否进行重载?
①当含有缺省值时,不可以重载
②当不含有缺省值时,可以重载
看下面的程序,因为第二个fun的形参有缺省值,所有调用第一个fun时编译器就无法判定需要调用哪一个fun,因此无法进行函数的重载;
但当这两个函数名相同,参数类型相同的函数,在参数个数存在较大差异时,在没有缺省值的情况下,编译器就很容易判定需要调用的是哪一个函数了,因此也就很容易实现函数的重载
void fun(int a,int b)
{
printf("2");
}
void fun(int a,int b,int c = 0)
{
printf("3");
}
int main()
{
fun(12,34);
fun(12,34,56);
}
函数原型:返回值类型 + 函数名称 + 参数列表(参数的类型和个数)
一定要特别注意,现有的编译器不能对函数返回值进行识别。
拓展内容
extern关键字的作用:
-
C中告诉编译器其所修饰的函数是一个外部函数;
-
C++中则可以指定编译器编译程序的方式,比如
extern “C++”
-
函数参数,形参,默认值
C++函数的形参
可以带默认值(编译时确定),形参列表默认值从右往左依次给,不能间隔。
C++函数的实参
调用函数时,实参列表默认从左往右依次给,不能间隔。
函数声明时,可以给形参名,也可以不给,主要给定函数的返回值和参数类型,并且也可以给形参初始化
例如:
void fun(int a,int b,int c,int d = 0,int e = 0)
{}
int main()
{
fun(11,22);//正确
fun(12, ,13);//错误
}
extern int Add(int,int = 0);
extern int Add(int,int b = 0);
同时有函数的声明和定义时,若声明和定义分离时,只能给声明默认值
- 动态内存
C:
int *p = (int *)malloc(sizeof(int));
free(p);
p = NULL;
C++:
new既可以开辟空间,也可以对空间初始化
int *p1 = new int;
int *p2 = new int(10);//添加了初始化
delete(p1);
p1 = NULL;
///数组空间开辟
int n;
cin>>n;
int *s1 =new int[n];
int *s2 =new int[n](100)//C99标准允许开辟并初始化
delete []s1;
delete []s2
注意:free和delete并不是把p删除,而且将p指向的堆区空间还给了系统
C语言中内存不足,malloc申请失败时,可以这样判定:
if(NULL== p)exit(1);
然而C++中内存不足时,new申请失败,没有机会给p置NULL,不能像C那样写,系统会抛出throw bad_alloc
异常
如果非要像C那样书写,就必须不让系统抛出异常,就可以用 if 处理:
ip = new(nothrow) int[n];
if(NULL == ip)exit(1);
类是设计的产物,对象是实例化的产物
设计类(不是定义类)的一般格式:
class 类名{
private:
成员表1;
public:
成员表2;
protected:
成员表3;
}; //最后的分号不可少;
访问限定符:
- private(
系统默认定义为私有
):说明的成员不能从外部进行访问; - public:说明的成员能从外部访问进行访问;
- protected:只能在该类所属的类的内部和其类的派生类中进行访问
私有和保护体现了类具有封装性(不能直接访问)。
类的更关键部分是对数据成员的操作,用函数来完成。
类是一种数据类型,定义时系统不为类分配存储空间,所以不能对类的数据成员初始化。
类中的任何数据成员也不能使用关键字extern、auto或register限定其存储类型。
一般来说,对于一个类中的数据成员我们一般设计成私有的,而函数成员被设计成共有的,如果需要从外部对成员进行操作,就必须通过公有函数完成,数据受到了极大保护,不受副作用影响,公有函数定义了类的接口(interface)。
对象的创建和使用
- 方法一:直接定义类的实例(编译时建立即运行前建立)
例如:
CGoods Car; int I;
定义创建了CGoods类的一个对象Car,同时为它分配了属于它自己的存储块,用来存放数据和对这些数据实施操作的成员函数(代码)。对象只在定义它的域中有效。
- 动态创建类的对象(程序运行时建立)
存储对象的方法
- 方法一:类说明中定义函数
系统为每一个对象分配了全套的内存,包括安放成员数据的数据区和安放成员函数的代码区。
有对象一定有空间,以此来标识该对象
对于没有数据成员的空类,当创建该类的对象时,会占据1byte
的大小(占位符),以此来标识这个对象;
class Empty
{
};
区别同一个类的各个不同的对象的属性是由数据成员决定的,不同对象的数据成员的内容是不一样的;而行为(操作)是用函数来描述的,这些操作的代码对所有的对象都是一样的。
这种方法太浪费空间了。
- 类说明外部定义函数
为每个对象分配一个数据区,代码区(放成员函数的区域)为各对象类共用。
那么怎么去区分代码区中处理各个不同对象的方法呢?
——this指针的引入,这样就节省了不少存储空间 ,具体关于this指针的介绍请参照C++的第四篇博客。
成员函数的定义
在类中对成员函数进行声明后,并未进行定义,在类外定义格式如下:
返回值类型 类名::函数名(参数表)
{……}//函数体
其中运算符“::
”称为作用域解析运算符,它指出该函数是属于哪一个类的成员函数,告诉编译器该函数是该类的某个成员函数的定义,而非全局函数。