C++对C语言的加强
1、namespace命名空间
1.1C++命名空间基本常识
所谓namespace，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。
一 ：<iostream>和<iostream.h>格式不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的。后缀为.h的头文件c++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h后缀的头文件里，c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。
因此，
1）当使用<iostream.h>时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；
2）当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用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> 和<iostream>等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"
1.2 C++命名空间定义以及使用方法
在C++中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突。
标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。
std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector等都定义在该命名空间中，使用时要加上using声明(using namespace std) 或using指示(如std::string、std::vector<int>).
因而：
| C中的命名空间 ●在C语言中只有一个全局作用域 ●C语言中所有的全局标识符共享同一个作用域 ●标识符之间可能发生冲突 C++中的命名空间●命名空间将全局作用域分成不同的部分 ●不同命名空间中的标识符可以同名而不会发生冲突 ●命名空间可以相互嵌套 ●全局作用域也叫默认命名空间 |
C++命名空间的定义：
namespace name { … } 使用整个命名空间：using namespace name;
使用命名空间中的变量：using name::variable;
使用默认命名空间中的变量：::variable
默认情况下可以直接使用默 认命名空间中的所有标识符
1.3 C++命名空间编程实践
代码例子1：
#include <iostream>
// 命名空间的引入方式
//第一种方式
//在输入输出的时候写
//第二种
using std::cout; //using 关键字 不是引入整个命名空间 而是引入命名空间一个变量
using std::endl;
//第三种
using namespace std; //using namespace 是引入整个命名空间
int aa;//是属于默认的全局作用域命名空间
//如何定义一个命名空间?
namespace namespaceA//定义一个命名空间 namespace是命名空间关键字类型， namespaceA 是命名空间的名字
{
// namespace A 空间领域
int a = 10;
int b = 20;
}
namespace namespaceB
{
int a = 20;
namespace namespaceC
{
struct teacher
{
int id;
char name[64];
};
}
namespace namespaceD
{
struct teacher
{
};
}
}
//使用自定义的命名空间
void test()
{
//using namespaceA::a;//真个test（）函数领域中所有的a 默认都是 namespaceA中的a
//using namespace namespaceA; //引入整个namespaceA空间
cout << "A::a = " << namespaceA::a << endl;
cout << "B::a = " << namespaceB::a << endl;
//cout << "a = " << a << endl;
//创建一个struct teacher的变量
//using namespace namespaceB::namespaceC;//把namepaceC中的所有定义的遍历都引入
//using namespaceB::namespaceC::teacher;
//namespaceB::namespaceC::teacher t;
using namespace namespaceB::namespaceC;
teacher t;
}
int main2(void)
{
//第一种使用命名空间变量的方式
std::cout << "你好" << std::endl;//直接使用
test();
return 0;
}代码例子2：
#include <stdio.h>
namespace NameSpaceA
{
int a = 0;
}
namespace NameSpaceB
{
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;
}1.4 结论
| 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、“实⽤用性”增强
#include <iostream>
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;
}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;
}4、struct 类型增强
案例1：
#include <iostream>
using namespace std;
//struct 关键字 class关键字 完成的功能是一样的
//区别后面介绍 抛砖
class c1
{
public:
protected:
private:
};
struct Teacher
{
public:
char name[32];
int age;
protected:
int a;
};
void main51()
{
Teacher t1; //
t1.age = 10;
printf("hello...\n");
system("pause");
}
/*
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;
}
*/案例2：
/*
C语⾔言的struct定义了⼀一组变量的集合，C编译器并不认为这是⼀一种新的类型
C++中的struct是⼀一个新类型的定义声明
*/
#include <iostream>
struct Student
{
char name[100];
int age;
};
int main(int argc, char *argv[])
{
Student s1 = {"wang", 1};
Student s2 = {"wang2", 2};
return 0;
}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++更加强调类型，任意的程序元素都必须显示指明类型 |
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);
return 0;
}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中的三目运算法当左值呢？ 当左值的条件：要有内存空间；C++编译器帮助程序员取了一个地址而已。 |
★★★8、const增强
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清楚的分清参数的输入和输出特性 |
Const修改形参的时候，在利用形参不能修改指针所向的内存空间
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;
} 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修饰的常量编译期间，就已经确定下来了。
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;
}const int c = 5; ≈ #define c 5
C++中的const常量与宏定义不同
const常量是由编译器处理的，提供类型检查和作用域检查 宏定义由预处理器处理，单纯的文本替换 。
| C语言中的const变量 ●C语言中const变量是只读变量，有自己的存储空间 C++中的const常量 ●可能分配存储空间,也可能不分配存储空间 ●当const常量为全局，并且需要在其它文件中使用，会分配存储空间 ●当使用&操作符，取const常量的地址时，会分配存储空间 ●当const int &a = 10; const修饰引用时，也会分配存储空间 |
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;
cout << "s = " << s <<endl; //1
return 0;
} 总结代码：
C++被增强的部分：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
struct teacher
{
int id;
char name[64];
};
//2 对全局变量的检测能力加强， 一个变量不管是声明，还是定义，只能出现一次
int g_val ; //全局变量
//int g_val = 10;// 右一个全局变量
//1 实用性的增强， 对于变量的定义的位置，可以随意，没有要求
int test1(void)
{
int i = 0;
for (i = 0; i < 10; i++){
}
for (int i = 0; i < 10; i++) {
}
return 0;
}
//2
void test2()
{
//teacher t1; //C++中 在使用struct 时候不需要再将 struct 写进来
}
//3
void f(int i)
{
cout << "i = " << i << endl;
}
//4 bool类型
void test3()
{
bool flag = true; //就代表逻辑真
flag = false; //就代表逻辑假
cout << "bool:sizeof() : " << sizeof(flag) << endl; //bool占一个字节。
flag = true; // 为真
cout << "flag = " << flag << endl; //当bool类型为true 他的数值是1
flag = false; //为假
cout << "flag = " << flag << endl;//当bool类型为false 他的数值是0
flag = 10;
cout << "flag = " << flag << endl;
flag = 100;
cout << "flag = " << flag << endl;
flag = -100;
cout << "flag = " << flag << endl; //不管给bool赋值什么样的非0数值，他是都是true 1
flag = 0;
cout << "flag = " << flag << endl;
//bool类型的取值，只有0 和1
if (flag == true) { //默认判断flag 是否为true
}
}
void test5()
{
int a = 10;
int b = 20;
(a < b ? a : b) = 30; //返回是a变量的别名
//a
cout << "a = " << a << endl;
(a < b ? 10 : b); //三木运算符 如果作为左值， 那么 返回的结果不能有常量
}
//c++对const的加强
void test6() {
const int a = 10; //c++的const 确实对a起了保护的作用，不能通过指针的间接赋值概念a的值
//int const b; //const int , int const 是等价的
int *p = (int*)&a; //当c++编译器 发现 对一个const的常量符号取地址，
*p = 20;//C语言中可以通过指针的间接赋值改变const变量 //*p 是改变的临时的变量 而不是 常量a符号
printf("a = %d\n", a);
}
#define A (3)
#define B (4)
void test7()
{
const int a = 3;
const int b = 4; //此时说明 c++中的const 就是一个常量， 永远不会被改变
//c++语言对const 的增强，将const 变量真正变成了常量
int array[a + b] = { 0 };
int array_2[A + B] = { 0 }; // define 和const 变量 在编译的阶段不一样， define是预处理器 const 是编译器
//#define ff (10)
const int ff = 10; //const 是编译器出 完全符合编译器的逻辑判断和此法分析
}
void test8()
{
const int ff = 10;
cout << "ff = " << ff << endl; //没有区域的划分
}
enum season {
SPR ,
SUM ,
AUT ,
WIN
};
void test9()
{
enum season s = SPR;
s = SUM; //为了增加枚举的可读性，
s = AUT;
s = WIN;
}
struct student
{
int id;
char name[64];
};
void change_stu(struct student *s)
{
s ->id = 10;
}
void change_stu2(const struct student *s)
{
//s->id = 10; //此时s所指向的区域是一个常量 不能够被修改
struct student s2;
s = &s2;
}
void change_stu3(struct student *const s)
{
s->id = 10;
//struct student s2;
//s = &s2; //s是一个常量指针
}
void change_stu4(const struct student *const s)
{
//s->id = 10;
//struct student s2;
//s = &s2; //s是一个常量指针
}
int g(int a, int b, int c)
{
return 100;//函数一定要有返回值， 如过函数没有返回值，也要加void
}
int main3(void)
{
f(3); //error 对于函数传参的检测能力更加的严格，
int r;
r=g(1, 2, 3); //C_++编译器 对函数形参传递 函数返回值 做了严格的检查
cout << "r=" << r << endl;
//test3();
//test5();
//test6();
test7();
test8();
return 0;
}C语言被增强的部分：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int g_val; //全局变量
int g_val = 10;// 右一个全局变量
typedef struct teacher
{
int id;
char name[64];
}teacher_t;
void f(int i)
{
printf("i = %d\n", i);
}
g()
{
return 10;
}
//3 C语言中的逻辑是与非
void test3()
{
int flag = 0; // C语言中 数值0表示为假
// int flag = 1; // C语言中 数值非0表示真 C语言中是通过数值是否为0 来分辨逻辑真假的。
}
//4 三目运算符的增强
void test4()
{
int a = 10;
int b = 20;
int min_value = 0;
//min_value = (a < b ? a : b);
//(a < b ? a : b) = 30;//返回的是一个数值， 10 ， 10 = 30
*(a < b ? &a : &b) = 30;
//*(a < b ? &10 : &b) = 30; //10 =30
printf("%d\n", a);
}
//5 c语言中的const
void test5()
{
const int a ;
//int const b; //const int , int const 是等价的
int *p = (int*)&a;
*p = 20;//C语言中可以通过指针的间接赋值改变const变量
printf("a = %d\n", a);
}
#define A (3)
#define B (4)
void test6()
{
int const a = 3;
int const b = 4; //再次说明 c语言中的 const 并不是一个常量，是一个变量 加了只读属性。
int array[A+ B] = { 0 }; //数组类型大小是固定， 将两个变量做长度，编译器无法确定长度
}
enum season {
SPR = 0,
SUM,
AUT,
WIN
};
void test7()
{
enum season s = SPR;
s = 0;
s = 1;
s = 2; // C语言对枚举类型的赋值， 是可以通过枚举的值，直接赋值的。
s = 136; //136 什么意思？
}
//1 实用性增强
int main4(void)
{
struct teacher t1; //在C语言中如果使用一个struct 复杂类型，那么必须将struct 关键字写进来
teacher_t t2;
printf("%d\n", g_val);
//f(1,2,3);//warning
int value = 0;
value = g(1, 2, 3, 4, 5);
printf("%d\n", value);
//test4();
//test5();
//test7();
return 0;
}