C++ 和 C 的关系、区别

一. C++对C语言的加强

1. namespace命名空间

1）当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std,需要这样做。std::cout。

2）c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。

3） C++命名空间的定义： namespace name { … }

4） using namespace NameSpaceA;

5） namespce定义可嵌套。

2. 实用性增强

C++种所有变量都可以在需要使用时再定义，事实上如今的C也支持这一点

3. 变量检测增强

  在C语⾔言中，重复定义多个同名的全局变量是合法的
  在C++中，不允许定义多个同名的全局变量	
  C语⾔言中多个同名的全局变量最终会被链接到全局数据区的同⼀一个地址空间上	
  int g_var;
  int g_var = 1;
  C++直接拒绝这种⼆二义性的做法。

4. struct类型增强

5. C++中所有变量和函数都必须有类型，摒弃了C语言的灰色地带

6. 新增bool关键字（占 1B 内存空间）

7. 三目运算符功能增强

#include <iostream>

using namespace std;

int main()
{
	int a = 10, b = 20;

	//返回一个最小数，并将最小数的变量赋值成30
	//三目运算符是一个表达式，表达式不能做左值
	(a < b ? a : b) = 30;
	printf("%d\n", a);//30

	return 0;
}

1）C语言返回变量的值，C++语言是返回变量本身。C语言中的三目运算符返回的是变量值，不能作为左值使用；C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方。

2）注意：三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用(a < b ? 1 : b )= 30;

3）C语言如何支持类似C++的特性呢？

当左值的条件：要有内存空间；C++编译器帮助程序员取了一个地址而已

8. const增强

1）

	//常整型
	const int c = 10;
	int const d = 20;

	//常量指针:e指向的内存数据不能被修改，但是本身可以修改
	const int* e;//int const* e
	
	//指针常量:f指向的内存数据可以被修改，但是本身不能被修改
	int* const f = NULL;

	//指针和它指向的内存空间都不能被修改
	const int* const g = NULL;

例如：int setTeacher(const Teacher* p)形参p指向的内存空间不能被修改

2）C++中的const修饰的，是一个真正的常量，而不是C中变量（只读）。在const修饰的常量编译期间，就已经确定下来了 

	const int a = 10;
	const int b = 20;
	int array[a + b] = { 0 };//在C中非法

3）C++中const和#define的区别

const常量是由编译器处理的，提供类型检查和作用域检查；宏定义由预处理器处理，纯粹的文本替换
C语言中的const变量：
C语言中const变量是只读变量，有自己的存储空间
C++中的const常量：
可能分配存储空间，也可能不分配存储空间。
当const常量为全局，并且需要在其它文件中使用，会分配存储空间。
当使用&操作符，取const常量的地址时，会分配存储空间。
当const int &a = 10;const修饰引用时，也会分配存储空间。

9.C++：真正的枚举

c语言中枚举的本质就是整型，枚举变量可以用任意整型赋值；而C++中枚举变量只能用被枚举的元素初始化

enum season { A, B, C };

int main()
{
	enum season s = A;
	s = B;
	
	cout << s << endl;//1
	
	return 0;
}

二、C++对C语言的拓展

1. 引用&（C++专属）

变量名实质上是一段连续存储空间的别名，是一个标号(门牌号)，通过变量来申请并命名内存空间，通过变量的名字可以使用存储空间。
引用可以看作是一个已定义变量的别名
语法： Type& name = var;

//一般引用
int a = 10;
int& b = a;//b就是a的别名
b = 20;//a = 20

//函数参数引用
void mySwap(int& a, int& b)
{
	int c = a;
	a = b;
	b = c;
}

int main()
{
	int x = 10, y = 20;
	mySwap(x, y);
	cout << x << "  " << y << endl;//20   10
	
	return 0;
}

引用的本质是C++编译器帮程序员取了变量地址

函数的引用
难点：当函数返回值为引用时，若返回栈变量，不能成为其他引用的初始值，也不能作为左值使用；若返回静态变量或全局变量，可以成为其他引用的初始值，既可以作为右值使用，也可以作为左值使用。

指针的引用

#include <iostream>

using namespace std;

struct Teacher
{
	int age;
	char name[20];
};

//c语言中二级指针的用法
int getAge1(Teacher** p)
{
	if (p == NULL)
	{
		return -1;
	}
	
	Teacher* tmp = NULL;
	tmp = (Teacher*)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -2;
	}
	tmp->age = 22;
	//p是实参的地址 *实参的地址 去间接修改实参的值
	*p = tmp;

	return 0;
}

//C++中指针的引用
int getAge2(Teacher*& p)
{
	p = (Teacher*)malloc(sizeof(Teacher));
	if (p == NULL)
	{
		return -3;
	}

	p->age = 33;
	
	return 0;
}

void freeTeacher(Teacher* p)
{
	if (p == NULL)
	{
		return;
	}
	free(p);
}

int main()
{
	Teacher* pT1 = NULL;

	//C
	getAge1(&pT1);
	cout << "age:" << pT1->age << endl;
	freeTeacher(pT1);

	//C++
	getAge2(pT1);
	cout << "age:" << pT1->age << endl;
	freeTeacher(pT1);

	pT1 = NULL;

	return 0;
}

常量引用
1）const& 相当于const int* const e;

	//常引用
	int x = 10;
	const int& y = x;//让变量拥有只读属性，不能通过y修改x

	const int& m = 5;//用字面量初始化常量引用会分配内存地址

2）作为函数参数时，常引用让实参变量拥有只读属性

void printTeacher(const Teacher& p)
{
	//这样p可以传地址，但是不能被函数改变
}

好了，其他内容就不写在这里了！