C++ 第2篇 C++在C语言的加强

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

2.1 namespace命名空间

2.1.1 C++命名空间基本常识

所谓namespace，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。

• 一 ：和<iostream.h>格式不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的。后缀为.h的头文件c++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h后缀的头文件
  里，c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。 因此，

  • 1）当使用<iostream.h>时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；
  • 2）当使用的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。

• 二： 由于namespace的概念，使用C++标准程序库的任何标识符时，可
  以有三种选择：

1）直接指定标识符。例如std::ostream而不是ostream。完整语句如下：

 std::cout	<<	std::hex	<<	3.4	<<	std::endl;	

2）使用using关键字。

using	std::cout;	
using	std::endl;	
using	std::cin;

以上程序可以写成 :

cout	<<	std::hex	<<	3.4	<<	endl;	

3）最方便的就是使用using namespace std;
例如： using namespace std;这样命名空间std内定义的所有标识符都有效（曝光）。就好像它们被声明为全局变量一样。那么以上语句可以如下写: cout <<hex << 3.4 << endl;因
为标准库非常的庞大，所以程序员在选择的类的名称或函数名 时就很有可能和标准库中的某个名字相同。所以为了避免这种情况所造成的名字冲突，就把标准库中的一切都被放在名字空间std中。但这又会带来了一个新问 题。无数原有的C++代码都依赖于使用了多年的伪标准库中的功能，他们都是在全局空间下的。所以就有了<iostream.h> 和等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"

2.1.2 C++命名空间定义以及使用方法

在C++中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突。

标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。

std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector等都定义在该命名空间中，使用时要加上using声明(using namespace std) 或using指示(如std::string、std::vector)

比较

C中的命名空间	C++中的命名空间
1、在C语言中只有一个全局作用域	1、命名空间将全局作用域分成不同的部分
2、C语言中所有的全局标识符共享同一个作用域	2、不同命名空间中的标识符可以同名而不会发生冲突
3、标识符之间可能发生冲突	3、命名空间可以相互嵌套
	4、全局作用域也叫默认命名空间

C++命名空间的定义：

namespace	name	{		…		}	

C++命名空间的使用：

使用整个命名空间：using namespace name; 
使用命名空间中的变量：using name::variable; 
使用默认命名空间中的变量：::variable 
默认情况下可以直接使用默 认命名空间中的所有标识符

2.1.3 C++命名空间编程实践

#include	<stdio.h>
namespace	NameSpaceA	
{	
				int	a	=	0;	
}	
namespace	NameSpaceB	
7
{	
				int	a	=	1;	
				namespace	NameSpaceC	
				{	
								struct	Teacher	
								{	
												char	name[10];	
												int	age;	
								};	
				}	
}	
int	main(void)	
{	
				using namespace	NameSpaceA;	
				using	NameSpaceB::NameSpaceC::Teacher;	
				printf("a	=	%d\n",	a);		//0
				printf("a	=	%d\n",	NameSpaceB::a);//1
				NameSpaceB::NameSpaceC::Teacher	t2;	
				Teacher	t1	=	{"aaa",	3};	
				printf("t1.name	=	%s\n",	t1.name);		//aaa
				printf("t1.age	=	%d\n",	t1.age);				//3
				return 0;	
}

2.1.4 结论

1） 当使用的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std ,需要这样做。std::cout。
2） c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。
3） C++命名空间的定义： namespace name { … }
4） using namespace NameSpaceA;
5） namespce定义可嵌套。

2.2 “实⽤性”增强

#include	<iostream>
8
using namespace	std;	
//C语⾔中的变量都必须在作⽤域开始的位置定义！！
//C++中更强调语⾔的“实⽤性”，所有的变量都可以在需要使⽤时再定义。
int	main(void)	
{	
				int	i	=	0;	
				cout	<<	"i	=	"	<<i	<<endl;	
				int	k;	
				k	=	4;	
				cout	<<	"k	=	"	<<k	<<endl;	
				return 0;	
}

2.3 变量检测增强

/*
				在C语⾔中，重复定义多个同名的全局变量是合法的
				在C++中，不允许定义多个同名的全局变量
				C语⾔中多个同名的全局变量最终会被链接到全局数据区的同⼀个地址空间上
				int	g_var;
				int	g_var	=	1;
				C++直接拒绝这种⼆义性的做法。
*/
#include	<iostream>
int	g_var;	
int	g_var	=	1;	
int	main(int	argc,	char	*argv[])	
{	
				printf("g_var	=	%d\n",	g_var);	
				return 0;	
}	

2.4 struct 类型增强

/*
				C语⾔的struct定义了⼀组变量的集合，C编译器并不认为这是⼀种新的类型
				C++中的struct是⼀个新类型的定义声明
*/
#include	<iostream>
struct	Student	
9
{	
				char	name[100];	
				int	age;	
};	
int	main(int	argc,	char	*argv[])	
{	
				Student	s1	=	{"wang",	1};	
				Student	s2	=	{"wang2",	2};	
				return 0;	
}

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

/*
				C++中所有的变量和函数都必须有类型
				C语⾔中的默认类型在C++中是不合法的
				函数f的返回值是什么类型，参数⼜是什么类型？
				函数g可以接受多少个参数？
*/
//更换成.cpp试试
f(i)	
{	
				printf("i	=	%d\n",	i);	
}	
g()	
{	
				return 5;	
}	
int	main(int	argc,	char	*argv[])	
{	
				f(10);	
				printf("g()	=	%d\n",	g(1,	2,	3,	4,	5));	
				getchar();	
				return 0;	
}

在C语言中
int f( )；表示返回值为int，接受任意参数的函数
int f(void)；表示返回值为int的无参函数

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

C++更加强调类型，任意的程序元素都必须显示指明类型

2.6 新增bool类型关键字

/*
			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
	*/
#include	<iostream>
using namespace	std;	
int	main(int	argc,	char	*argv[])	
{	
				int	a;	
				bool	b	=	true;	
				printf("b	=	%d,	sizeof(b)	=	%d\n",	b,	sizeof(b));	
				b	=	4;	
				a	=	b;	
				printf("a	=	%d,	b	=	%d\n",	a,	b);	
				b	=	-4;	
				a	=	b;	
				printf("a	=	%d,	b	=	%d\n",	a,	b);	
				a	=	10;	
				b	=	a;	
				printf("a	=	%d,	b	=	%d\n",	a,	b);	
				b	=	0;	
				printf("b	=	%d\n",	b);	
11
				return 0;	
}

2.7 三⽬运算符功能增强

#include	<iostream>
using namespace	std;	
int	main(void)	
{	
				int	a	=	10;	
				int	b	=	20;	
				//返回⼀个最⼩数 并且给最⼩数赋值成30
				//三⺫运算符是⼀个表达式 ，表达式不可能做左值
				(a	<	b	?	a	:	b	)	=	30;	
				printf("a	=	%d,	b	=	%d\n",	a,	b);	
				return 0;	
}	

1）C语言返回变量的值 C++语言是返回变量本身

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

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

3）C语言如何支持类似C++的特性呢？
当左值的条件：要有内存空间；C++编译器帮助程序员取了一个地址而已

2.8 const增强

2.8.1 const基础知识

#include	<iostream>
int	main(void)	
{	
				//const	定义常量--->	const	意味只读
				const int	a;	
				int const	b;	
				//第⼀个第⼆个意思⼀样 代表⼀个常整形数
				const int	*c;	
				//第三个	c是⼀个指向常整形数的指针(所指向的内存数据不能被修改，但是本⾝可以修改)
				int	*	const	d;	
				//第四个	d	常指针（指针变量不能被修改，但是它所指向内存空间可以被修改）
				const int	*	const	e	;	
				//第五个	e⼀个指向常整形的常指针（指针和它所指向的内存空间，均不能被修改）
				return 0;	
}

合理的利用const的好处，

• 1 指针做函数参数，可以有效的提高代码可读性，减少bug；
• 2 清楚的分清参数的输入和输出特性

int setTeacher_err( const Teacher *p)
Const修改形参的时候，在利用形参不能修改指针所向的内存空间

2.8.2 C语言中的“冒牌货”

#include	<stdio.h>
int	main()	
{	
		const int	a	=	10;	
		int	*p	=	(int*)&a;		
		printf("a===>%d\n",	a);	
		*p	=	11;									
		printf("a===>%d\n",	a);	
		return 0;																				
}

2.8.3 const 和 #define 的相同

#include	<iostream>		
//#define	N	10	
int	main()	
{	
		const int	a	=	1;			
		const int	b	=	2;			
		int	array[a	+	b]	=	{0};	
		int	i	=	0;																													
	for(i	=	0;	i	<	(a+b);	i++)	
	{	
		printf("array[%d]	=	%d\n",	i,	array[i]);	
	}																																												
		return 0;																				
}

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

2.8.4 const 和 #define 的区别

#include	<iostream>
void	fun1()	
{	
		#define	a	10
		const int	b	=	20;	
}	
void	fun2()	
{	
		printf("a	=	%d\n",	a);	
		//printf("b	=	%d\n",	b);
}	
int	main()	
{	
		fun1();	
		fun2();	
		return 0;	
}

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

const int c = 5; ≈ #define c 5

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

const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器处理，单纯的文本替换

C语言中的const变量

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

C++中的const常量

可能分配存储空间,也可能不分配存储空间 
当const常量为全局，并且需要在其它文件中使用，会分配存储空间 
当使用&操作符，取const常量的地址时，会分配存储空间 
当const int &a = 10; const修饰引用时，也会分配存储空间 

2.9 真正的枚举

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

#include	<iostream>
using namespace	std;	
enum	season	{SPR,SUM,AUT,WIN};	
int	main()	
{	
		 enum	season	s	=	SPR;	
	    //s	=	0;	//error,但是C语⾔可以通过
		s	=	SUM;	
15
		cout	<<	"s	=	"	<<	s	<<endl;			//1
		return 0;