Day4| C++—C++对C的扩展

1、作用域运算符 

作用域运算符:: ，描述谁是谁的谁

通常情况下，如果有两个同名变量，一个全局变量，另一个是局部变量，那么局部变量在起作用域内具有较高的优先权，它将屏蔽全局变量。

举例：

#include <iostream>
using namespace std;

int a = 10;

void test01()
{
    int a = 20;
    cout<<"a="<<a<<endl;//局部变量
    cout<<"a="<<::a<<endl;//全局变量
}

int main()
{
    test01();
    return 0;
}

输出结果如下图：

通过这个例子我们可以看出，作用域运算符可以用来解决局部变量与全局变量的重名问题，记载局部变量的作用域内，可以用 :: 对屏蔽的同名的全局变量进行访问。 

2、名字控制

C++允许我们对名字的产生和名字的可见性进行控制。

（1）、C++的命名空间

在C++中，名称（name）可以使符号常量、变量、函数、结构、枚举、类和对象等等。为了避免在大规模程序的设计中，以及在程序员使用各种各样的C++库时，在这些标识符命名发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好的控制标识符的作用域。 

举例代码：

#include <iostream>
using namespace std;

namespace A {
       int data1 = 10;//这个地方使用了namespace关键字
}
namespace B {
       int data1 = 20;
}

void test02()
{
    int a = 20;
    cout<<"data1="<<A::data1<<endl;//使用作用域::调用，稳定安全
    cout<<"data1="<<B::data1<<endl;

int main()
{
    test02();
    return 0;
}

对于上述代码，运行结果如下图所示： 

注意：

①、命名空间只能在去全局范围内定义

②、命名空间也可以嵌套

③、命名空间是开放的，可以随时添加新成员

④、声明和实现可以分离

声明和实现分离举例：

#include <iostream>
using namespace std;

namespace C {
   int a = 10;
     void set_a(int data);
     int get_a(void);
}

void C::set_a(int data)//一定要加上作用域，属于C
{
    a = data;
}

int C::get_a(void)//一定要加上作用域，属于C
{
    return a;
}

void test03()
{
    C::set_a(100);//给a赋值
    cout<<"a="<<C::get_a()<<endl;
}

int main()
{
    test03();
    return 0;
}

对于以上代码，执行结果如下图：

 ⑤、无命名空间。意味着命名空间中的标识符只能在文件内访问，相当于给这个标识符加上了static，使得其可以作为内部连接。【无命名空间里面的数据和方法只能在当前源文件使用】

内部连接：只能在当前源文件使用

外部链接：可以在其他源文件使用

（2）、命名空间别名

代码举例，使用方法为： namespace 别名 = 原命名空间名;

#include <iostream>
using namespace std;

namespace LEMON {
   int a = 10;
     void set_a(int data);
     int get_a(void);
}

void LEMON::set_a(int data)//一定要加上作用域，属于C
{
    a = data;
}

int LEMON::get_a(void)//一定要加上作用域，属于C
{
    return a;
}

void test03()
{
    namespace C = LEMON;// 命名空间别名
    C::set_a(100);//给a赋值
    cout<<"a="<<C::get_a()<<endl;
}

int main()
{
    test03();
    return 0;
}

（3）、命名空间声明，using声明修饰命名空间里面的某些数据或方法

这种方式不推荐使用，如果存在同名是会出现冲突的，举例如下图：

 ①、using声明碰到函数重载，同名函数全部有效

②、using是修饰整个命名空间

 注意：推荐使用::

3、全局检测增强

4、C++中所有变量和函数都必须要有类型

函数的参数必须有类型

如果函数没有参数调用的时候不能传参

5、更严格的类型转换

在C++中，不同类型的变量一般是不能直接赋值的，需要相应的强转。

6、结构体增强

①、C++使用结构体类型的时候可以不用加struct

C语言中结构体：struct Stu{}；

C++中结构体 stu lucy；

②、C++中结构体成员可以是函数，如下图示例

7、新增bool类型

bool的只能赋值为true（非0）或者false（0），示例结果如下：

8、三目运算符功能增强

①、C语言中的三目运算符 a>b ? a:b 返回的是a或者b的值，C语言使用(a>b ? a:b) = 100;是会报错的；

②、C++语言中的三目运算符 a>b ？ a:b返回的是a或者b的引用（a或b的变量名），代码举例如下图所示：

9、const增强（重点）

①、C语言中const修饰的普通变量是只读变量

②、C++中如果使用常量初始化const修饰变量，那么该变量就是符号常量

举例：

const int num = 10;
num是符号常量，被放入符号常量表中，这个时候num没有空间
如果对num取地址，这个时候系统才会为num开辟空间

示例代码：

#include <iostream>
using namespace std;

void test04()
{
    const int num = 10;
    int *p = (int*)&num;
    *p = 1000;
    cout<<"*p="<<*p<<endl;//通过指针访问可以访问开辟的空间，*p指向该空间
    cout<<"num="<<num<<endl;//通过变量名访问只能访问符号常量表
}

int main()
{
    test04();
    return 0;
}

③、如果以普通变量初始化 const修饰变量，会立即开辟空间（就不会有符号常量）

举例：

int b = 10;
const int a = b;
这种情况就立即开辟空间，没有符号常量表

举例代码：

#include <iostream>
using namespace std;

void test04()
{
    int b = 10;
    const int a = b;
    int *p = (int*)&a;
    *p = 1000;
    cout<<"*p="<<*p<<endl;
    cout<<"a="<<a<<endl;
}

int main()
{
    test04();
    return 0;
}

执行结果如下图：

④、const修饰全局限量a，如果用常量初始化，那么a被分配到文字常量区

示例代码：

const int a = 10;
void test04()
{
    int *p = (int*)&a;
    *p = 1000;//这个地方会出现段错误
    cout<<"*p="<<*p<<endl;
    cout<<"a="<<a<<endl;
}

⑤、const如果修饰的是自定义数据类型的变量，直接开辟空间

举例代码：

#include <iostream>
using namespace std;

struct Stu
{
    int num;
    char name[32];
};

void test04()
{
   const Stu lucy={100,"lucy"};
   Stu *p = (Stu *)&lucy;
   p->num = 1000;
    cout<<p->num<<" "<<p->name<<endl;
}

int main()
{
    test04();
    return 0;
}

运行结果：

 注意：尽量以const替换#define。

在旧版本C中，如果想建立一个全局变量，我们需要使用到预处理命令#define，例如“ #define Max 1024；”，我们定义的宏在预处理阶段就会将Max替换成1024，如果我们在这个常量编译时出现错误，只会提示1024，而无法准确知道表达什么，不利于我们修改bug，解决的办法就是用常量替换上面的宏。 

#define 和 const 区别：

1、const有类型而 #define无类型；

2、const有作用域，而#define不注重视作用域，#define不能作为类的成员

10、引用（重要）

引用的本质：给已有的变量取别名

（1）、引用的定义方式：

int num = 100；
int &b = num;
num的别名b，注意不是取b的地址，只是表述b是num的别名，b不占地址

int &b = #这种情况b占空间

代码举例：

#include <iostream>
using namespace std;

void test04()
{
   int num = 100;
    int &b = num;

    cout<<"num="<<num<<endl;
    cout<<"b="<<b<<endl;//输出引用值

    cout<<"num="<<&num<<endl;
    cout<<"b="<<&b<<endl;//输出地址
}

int main()
{
    test04();
    return 0;
}

运行结果：

 定义步骤：

取地址修饰别名——>给哪个变量取别名就定义哪个变量——>从上往下，整体替换

案例1：给数组取别名

int arr[5] = {1,2,3,4,5};

int (&new_arr)[5] = arr;
这个地方其实也就是数组指针和指针数组的区别

（2）、引用必须初始化

比如这种形式 int &b；是非法的；

（3）、引用一旦确定谁是谁的别名，就不能更改

（4）、引用作为函数的参数，可以替代指针变量

代码举例：

#include <iostream>
using namespace std;

void swap_number(int &a1,int &b1)
{
   int c;
    c = a1;
    a1 = b1;
    b1 = c;
}

void test04()
{
   int a = 10;
   int b = 100;

    cout<<"a="<<a<<","<<"b="<<b<<endl;
    swap_number(a,b);
    cout<<"a="<<a<<","<<"b="<<b<<endl;
}

int main()
{
    test04();
    return 0;
}

 运行结果：

 引用作为函数的参数好处：

函数内部直接通过引用操作外部变量的值；

省去了指针操作；

函数的形参不拥有新的空间（节约空间）

（5）、常引用，加count，例如：const int &b = 10；

常引用一般作为函数的参数，防止函数内部修改外部空间的值

代码举例：

#include <iostream>
using namespace std;

//这种情况常引用，我们既节省了空间又防止函数内部修改外部变量的值
//如果不用常引用，我们可以直接在函数内对外部值进行修改
void printf_num(const int &a1)
{
   cout<<"a="<<a1<<endl;
}

void test04()
{
   int a = 10;
   printf_num(a);
}

int main()
{
    test04();
    return 0;
}

运行结果：

 （6）、引用作为函数的返回值类型

①、通过函数的返回值，在外界操作函数内部申请的空间

举例代码：

#include <iostream>
using namespace std;

int& get_data(void)
{
   static int data = 100;
   //不要返回 普通局部变量的引用
   return data;//返回谁外界的a就给谁取别名
}

void test04()
{
   int &a = get_data();
   cout<<"data="<<a<<endl;
}

int main()
{
    test04();
    return 0;
}

运行结果：

②、引用作为函数的返回值类型，可以完成链式操作

后面再补

（7）、引用的本质：常量指针变量

int num = 10;
int &b = num;

//底层实现
//b是只读 *b可读可写

int * const b = #
*b = 100;

篇幅有点长，剩下部分下一篇接着写