C++中变量定义&作用域运算符&引用&const修饰符&C++字符串&强制类型转换

题头的话：长按点赞可私我赠送50+本C与C++书籍电子书资源

C++的变量定义举例

#include<iostream>
using namespace std;
int main()
{
    struct student
    {
        int no;
        float math;
    };
    int n;
    cin>>n;
    student wang;
    //C++中变量的定义语句可以出想在程序中的任意位置；可以使用结构体名定义变量。
    wang.no=n;
    cin>>wang.math;
    cout<<wang.no<<" "<<endl;
}

相较于C语言，C++在变量定义方面做了两种较大的改变。一是允许变量定义语句出现在程序任何位置；二是允许直接使用结构体名定义变量。类似的，在C++语言中联合名，枚举名，也可以在定义后独立的作为类型名使用。而C语言中，局部变量说明必须置于可执行代码段之前，不允许局部变量声明和可执行代码混在一起。

作用域运算符

同名的局部变量比全局变量有更高的优先级。
C语言中，只能在变量的作用域内使用该变量，不能使用其他作用域中的变量：

#include<iostream>
using namespace std;
float a=2.4			//全局变量
int main()
{
	int=8;			//局部变量
	cout<<a<<endl;
}

程序中有两个变量a：局部变量和全局变量。
如果想在主函数中输出全局变量，那就需要作用域运算符::，他能指定所需的作用域。即：

#include<iostream>
using namespace std;
float a=2.4			//全局变量
int main()
{
	int=8;			//局部变量
	cout<<a<<endl;
	cout<<::a<<endl;//::a表示全局作用域中的变量a
}

程序运行结果为

8
2.4

注意 ：不能用::访问函数中的局部变量。在C++中作用域运算符还用来限定类的成员

引用

引用的基本操作

引用的本质就是懒人版指针，超好用
作用：
给变量起小名
就好像喊努尔哈赤“野猪皮”的小名一样，都是在称呼同一个人
语法：

数据类型&小名=原名;

例如：

#include <iostream>
using namespace std;
int main()
{
	int  a=10;
	//int &b；		错误，引用必须初始化！我们不能创建一个引用，但不说明它的主子是谁。
	int &b=a;

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;

	b=100;

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;

	int c=200;
	b=c;			//这只是一个赋值，而不是更改引用。
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;

	return 0;
}

结果：

a=10
b=10
a=100
b=100
a=200
b=200

起的别名小名 和原名共享一段储存空间。引用不是值，不占储存空间。所以引用本身需要一个合法的内存空间。
注意

• 你如果想让某一“b”成为小名，那你就一定要立即给它一个主子（如， int &b=a;）初始化 除非这个引用是用作函数的参数或者返回值（下面会解释打狗也得看主人）为引用提供的初始值应为变量（包括对象）。
• 有趣的是：你可以使用一个引用去初始化另一个引用

int num=50;
int &ref1=num;
int &ref2=ref1;
ref2=100;//ref1和num都被修改为100

• 引用一旦认了主子，那就不能更改主子了。（如， int &b=a;然后 int &b=c;是不可以的）不可更改
• 由于引用不是变量，所以不能说明引用的引用，也不能说明数组元素的类型为引用或指向引用的指针。

int &a[5];		//错误
int&*p=a;		//错误
//由于指针也是变量，因此可以说明对指针变量的引用。
int *a;
int *&p=a;
int b;
p=&b;			//a指向变量b

引用做函数参数

函数传参时，可以使用引用让形参修饰实参
简化指针修改实参前面有提“引用的本质就是懒人版指针”
如最简单的函数交换。

#include <iostream>
using namespace std;

void Swap01(int x,int y)    //大家知道，该方法并未改变实参。并不能实现交换功能。
{
    int temp=x;
    x=y;
    y=temp;
}

void Swap02(int *x,int *y)  //地址传递，形参会修饰实参，能实现交换功能。
{
    int temp=*x;
    *x=*y;
    *y=temp;
}

void Swap03(int &x,int &y)  //引用传递（其中引用在传参的时候就已经初始化了。）
    int temp=x;
    x=y;
    y=temp;
}

int main()
{
    int a=10;
    int b=20;

    Swap01(a,b);            //方法一

    cout<<"Swap01 a="<<a<<endl;
	cout<<"Swap01 b="<<b<<endl;    //结果并未发生改变，只是形参发生了改变。
    cout<<endl;

  //输出结果为：
  //Swap01 a=10
  //Swap01 b=20


    a=10;
    b=20;

    Swap02(&a,&b);          //方法二

    cout<<"Swap02 a="<<a<<endl;
	cout<<"Swap02 b="<<b<<endl;    //结果发生改变。形参只是它的地址，真正改变的是地址上的值。
    cout<<endl;

  //输出结果为：
  //Swap02 a=20
  //Swap02 b=10


    a=10;
    b=20;

    Swap03(a,b);            //方法三（传参时认主了）

    cout<<"Swap03 a="<<a<<endl;
	cout<<"Swap03 b="<<b<<endl;    //结果发生改变，是简化版的指针。
    cout<<endl;

  //输出结果为：
  //Swap03 a=20
  //Swap03 b=10

}

指针相当于手动挡
引用相当于自动挡
引用本质为指针常量：能修改地址的数据但是不能改变指向。
指针：那我走？

总的结果：

Swap01 a=10
Swap01 b=20

Swap02 a=20
Swap02 b=10

Swap03 a=20
Swap03 b=10

引用做函数返回值

即函数调用作为左值
不要返回局部变量的引用
见例：

#include<iostream>
using namespace std;

//引用做函数返回值

//1，不要返回局部变量的引用
int &ErrorFunction()//返回一个给你们瞅瞅。这里加了“&”，即是用引用的方式返回这个变量。
{
    int a=10;       //局部变量存放在栈区，用完即销毁。
    return a;       //这里返回了局部变量的引用
}
//2，函数调用作为左值
int &CorrectFunction()//
{
    static int b=10;       //局部变量生命周期提长。变成了静态变量，存入全局区。
    return b;       //这里返回了局部变量的引用
}


int main()
{
    int &ref=ErrorFunction();
    cout<<"ref="<<ref<<endl;
    //输出结果为：
    //ref=10
    //咦？这不是对的吗？上面明明讲已经销毁了。
    //原因是编译器做了保留（编译器：照顾一下这个傻子）我们再输出一次看看
    cout<<"ref="<<ref<<endl;
    //输出结果为：
    //ref=4199010
    //乱码，错误。a的内存已经释放。这里是非法操作了。不要返回局部变量的引用。
    cout<<endl;
    cout<<endl;


    //如果函数做左值，那么必须返回引用。
    int &ref2=CorrectFunction();
    cout<<"ref2="<<ref2<<endl;
    //输出结果为：
    //ref2=10
    //我们再输出一次看看
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    //输出结果为：
    //ref2=10
    //ref2=10
    //ref2=10
    //ref2=10
    //ref2=10
    //ref2=10
    //没问题。
    cout<<endl;
    cout<<endl;


    CorrectFunction()=20;//如果函数的返回值是一个引用，那么这个函数调用可以做左值。
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    cout<<"ref2="<<ref2<<endl;
    //输出结果为：
    //ref2=20
    //ref2=20
    //ref2=20
    //ref2=20
    //ref2=20
    //ref2=20
    //函数调用作为左值,等号左边为左值。
    cout<<endl;
    cout<<endl;
}

总的结果：

ref=10
ref=4199040


ref2=10
ref2=10
ref2=10
ref2=10
ref2=10
ref2=10
ref2=10


ref2=20
ref2=20
ref2=20
ref2=20
ref2=20
ref2=20

引用的本质

建议新手先看完下面“const修饰符”
引用本质为指针常量：能修改地址的数据但是不能改变指向。
如果你创建了一个引用

int a=10;
int &ref =a;

内部发现ref是引用，则自动转换为

int *const ref =&a;

指针常量不可以改变指针指向，这也说明了为什莫引用不可以改。
然后你写下了ref=20;,编译器又贴心地帮你转换为*ref=20;
指针：让我们帮帮这个不会指针的傻子
程序员骂骂咧咧地退出了直播间

• 有空指针，无空引用。
• 引用不能用数据类型初始化，即int&ref=int;是错误的。

const修饰符

之前C语言中，若想定义一个常量，一般用# define.例如：

# define PI 3.1415926；

而在C++中，这边建议使用更“灵活安全”的const 修饰符方式来定义常量呢亲。例如：

const float PI =3.1415926；//这个常量有类型，有地址，可以使用指针指向这个值，但不能修改它。

即CONST修饰新参，防止误操作。
注意

• 你如果想让某一“PI”或其他字符成为常量，那你就一定要立即给它一个值（如，3.1415926）初始化
• 你已经让它成为不变的常量了那你就不能再修改它的值。做人不能反反复复
• 相比# define，const制造的常量有自己的数据类型，从而让程序更清楚地知道你在干什莫。具有更良好的检验性
• 函数参数也可以用const说明！这样函数内部的实参就不会再被改动，确保原数据不被破坏只读

常量引用

使用场景：
在函数中

void Function(const int & x){
//在这个内部你就不能改变实参了/形参就不能改变外面的实参了/防止误操作改变实参
}

const可以与指针一起使用（这是基础）

const中文翻译：常量
这里注意const位置
使用字符串解释的时候相当魔幻
const修饰指针—常量指针值不变的指针

int a=10;
int b=10;
int *p=&a;

const int *p=&a
特点：指针的指向可以改，指针指向的值必须是固定值。

*p=20;	//错误：指针指向的值必须是固定值
p=&b；	//正确：指针的指向可以改

const修饰常量—指针常量指向不变的指针

int a=10;
int b=10;
int *p=&a;

int const *p=&a
特点：指针的指向不可以改，指针指向的值可以改变。

*p=20;	//正确：指针指向的值可以改变
p=&b；	//错误：指针的指向不可以改

const既修饰常量又修饰常量

int a=10;
int b=10;
int *p=&a;

const int const *p=&a
特点：指针的指向不可以改，指针指向的值也不可以改变。

*p=20;	//错误：指针指向的值不可以改变
p=&b；	//错误：指针的指向不可以改

C++字符串

C型字符串

char str[]="hello world";
cout<<str<<endl;

注意

• char 字符串名 []
• 等号后面要用双引号括起来字符串

C++中的string类型

#include <string>           //使用字符串string类型的程序应包含头文件<string>
#include <iostream>
using namespace std;
int main()
{
	string s,t;
	cout<<"请输入一串字符"<<endl;
	cin>>s;                 //由键盘键入一行文本，并把它赋给string类型的变量s
                            //注意
                            //由此方式键入的字符串中不能包含空白字符。
    t="i lick C++";
    cout<<"字符串的输出"<<endl<<s<<endl<<t<<endl;
    cout<<s.append("ok!")<<endl;    //append为string类的成员函数
}

结果为：

请输入一串字符
BC
字符串的输出
BC
i lick C++
BCok!

C++强制类型转换

C语言中将一个表达式强制转换为所需类型的一般形式：
（数据类型）（表达式）
C++中除了保留上述转换方式外，还提供了一种更方便，合理的转换方式：
数据类型（表达式）
说明
（1）通过强制类型转换，得到一个所需类型的中间值，该中间值被引用之后即自动释放，原来表达式值的类型并未改变。如下列代码段：

int b;
float f;
f=float(b);

（2）强制类型转换符优先级较高，仅对紧随其后的表达式起作用，而对其他部分的部分不起作用。
（3）强制类型转换应当用在不做转换将影响表达式的正确性或精度、或不能完成相应的场合，而对系统可以自动转换类型的场合。