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*)#
*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;
篇幅有点长,剩下部分下一篇接着写