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 = &num;这种情况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 = &num;
*b = 100;

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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值