C++（1）——与C的区别，类和对象

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
  					   }

2. 常量
   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
从以上的程序中可以看出，常变量和宏有的一拼！！！ 均在运行前的编译过程就被替换。

3. 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关键字的作用：

1. C中告诉编译器其所修饰的函数是一个外部函数；

2. C++中则可以指定编译器编译程序的方式，比如extern “C++”

3. 函数参数，形参，默认值

   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);

同时有函数的声明和定义时，若声明和定义分离时，只能给声明默认值

5. 动态内存

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;
}; //最后的分号不可少;

访问限定符：

1. private（系统默认定义为私有）：说明的成员不能从外部进行访问；
2. public：说明的成员能从外部访问进行访问；
3. protected：只能在该类所属的类的内部和其类的派生类中进行访问

私有和保护体现了类具有封装性（不能直接访问）。

类的更关键部分是对数据成员的操作，用函数来完成。

类是一种数据类型，定义时系统不为类分配存储空间，所以不能对类的数据成员初始化。

类中的任何数据成员也不能使用关键字extern、auto或register限定其存储类型。

一般来说，对于一个类中的数据成员我们一般设计成私有的，而函数成员被设计成共有的，如果需要从外部对成员进行操作，就必须通过公有函数完成，数据受到了极大保护，不受副作用影响，公有函数定义了类的接口（interface）。

对象的创建和使用

1. 方法一：直接定义类的实例（编译时建立即运行前建立）
   例如：

CGoods Car；  int I;

定义创建了CGoods类的一个对象Car，同时为它分配了属于它自己的存储块，用来存放数据和对这些数据实施操作的成员函数（代码）。对象只在定义它的域中有效。

2. 动态创建类的对象（程序运行时建立）

存储对象的方法

1. 方法一：类说明中定义函数

系统为每一个对象分配了全套的内存，包括安放成员数据的数据区和安放成员函数的代码区。

有对象一定有空间，以此来标识该对象

对于没有数据成员的空类，当创建该类的对象时，会占据1byte的大小（占位符），以此来标识这个对象；

class Empty
{ 
};

区别同一个类的各个不同的对象的属性是由数据成员决定的，不同对象的数据成员的内容是不一样的；而行为（操作）是用函数来描述的，这些操作的代码对所有的对象都是一样的。

这种方法太浪费空间了。

2. 类说明外部定义函数

为每个对象分配一个数据区，代码区（放成员函数的区域）为各对象类共用。
那么怎么去区分代码区中处理各个不同对象的方法呢？
——this指针的引入，这样就节省了不少存储空间 ，具体关于this指针的介绍请参照C++的第四篇博客。

成员函数的定义

在类中对成员函数进行声明后，并未进行定义，在类外定义格式如下：

返回值类型 类名::函数名(参数表)
  {……}//函数体

其中运算符“::”称为作用域解析运算符，它指出该函数是属于哪一个类的成员函数，告诉编译器该函数是该类的某个成员函数的定义，而非全局函数。