C++学习（day2）

四. C++中的字符串

4.1 C++支持两种风格的字符串

1. C语言风格的字符串依然支持，使用字符数组的形式存储字符串，字符串标志：‘\0’

2. C++风格的字符串，本质上是string类的对象

使用要求：需要加头文件：#include

4.2 string类型的赋值和初始化

1. 单个数据的初始化和赋值

   方式		解释
   方式1	string s2 = “ni hao”;
   方式2	string s3(“shang hai”);
   方式3	string s4{“zhangpengpeng”};
   方式4	string s5(5,‘A’);	第一个参数是要赋值的个数 第二个参数是要辅的值

2. 多个数据的初始化和赋值

   方式	string s1 = “hello world”;
   拷贝构造函数	string s2(s1);
   使用旧字符串给新字符串初始化	string s3 = s1;
   两个字符串连接,给新字符串初始化	string s4 = s1+s2;
   两个字符串之间直接赋值	s1 = s4;

4.3 C风格和C++风格的字符串互换

1. C风格的字符串可以无条件转换为C++风格字符串，原因是C++兼容C的语法

2. C++风格的字符串转换为C风格字符串需要调用成员函数：c_str（）、data()

   方式	C++风格字符串转换为c风格字符串调用成员函数
   strcpy(s1,s2.c_str());	s2.c_str()
   strcpy(s1, s2.data());	s2.data()

4.4 string类中三个重要成员函数

函数	解释
size() / length()	求字符串的实际长度,相当于strlen
empty()	判空
clear()	清空

4.5 string类型的比较

1. string类型的比较，可以直接使用关系运算符进行比较(如: < > ==)

2. 而C风格的字符串比较只能使用strcmp函数来完成

4.6 string类型的成员访问 at()

方式
使用中括号 a[1]=‘a’	可以使用中括号进行下标访问，但是，该访问不做越界检查 不友好
成员函数at s.at(6)=‘a’	该访问方式进行下标越界检查 友好的

6.8 string类型数据的输入

1. 不带空格的输入：cin

2. 带空格的输入：getline()

五、bool类型

1. C语言不支持bool类型，但是C++支持

2. bool类型的值只有两个：true(非0数字)、false(0)

3. true和false这两个属于关键字，是真和假的常量，不可用做标识符

4. bool类型的数据，默认使用数字表示真假，如果想要使用单词表示真假，则需要加上boolalpha，在此之后全部都使用单词表示

   如果想要继续使用数字表示真假，则需要加上noboolalpha即

5. bool类型所占内存大小为1字节，原则上只需要使用1位即可，但是，计算机分配资源的基本单位为字节，所以，给bool类型分配1字节大小空间

六、引用（reference）

6.1 引用概念

1. 引用是C++对C的非常重要的扩充

2. 作用：相当于给变量的内存空间重新起个别名。例如，宋江 别名：及时雨、孝义黑三郎

6.2 定义引用

1. 定义格式：数据类型 &引用名 = 引用的目标； //人 &及时雨 = 宋江；

   举个例子：

   int num = 520;

   int &r = num; //此时变量r和变量num是同一个内存空间的两个名字（左值引用）

2. 总结==&==的用途

   • 两个&表示逻辑与运算

   • 作为位运算，一个&表示按位与运算

   • 作为取地址运算符，一个&表示取得变量的内存地址

   • 定义引用时，是身份的象征，表明定义的是引用变量

3. 左值和右值

   左值：既可以放在等号（赋值）左侧也可以放在等号右侧的值，可以对其进行取地址，例如：变量

   右值：只能放在等号右侧的值，不能对其取地址，例如常量、临时值

4. 使用要求

   定义引用时，必须用其引用的目标对其进行初始化

   引用的目标一旦指定，在程序中就不能对其进行更改了

   引用与其目标是同一内存空间，其大小跟目标一致，地址跟目标一致

   一个目标，可以有多个引用，这多个引用都是同一块内存空间的名字

6.3 引用的基本使用

#include <iostream>using namespace std;int main()
{int num = 520; // 在内存空间随机申请4字节，存放520，内存名字叫num// 定义引用目标为numint &r = num; // 此时r所表示的内存跟num表示的一致cout << "num = " << num << "   r = " << r << endl;                              // 相等cout << "&num = " << &num << "   &r = " << &r << endl;                          // 相等cout << "sizeof num = " << sizeof(num) << "  sizeof r = " << sizeof(r) << endl; // 相等cout << "typeid name of num = " << typeid(num).name() << endl;cout << "typeid name of r = " << typeid(r).name() << endl; // iint key = 1314;r = key;                                                                // 该语句合法，但是不是将引用改变目标，而是将key值赋值给rcout << "num = " << num << "   r = " << r << "  key = " << key << endl; // 相等cout << "&num = " << &num << "   &r = " << &r << "  &key = " << &key << endl;int &f = r;                                                               // 两个引用指向同一个目标cout << "num = " << num << "   r = " << r << "  f = " << f << endl;       // 相等cout << "&num = " << &num << "   &r = " << &r << "  &f = " << &f << endl; // 相等return 0;
}

6.4 引用做形参

由于引用的引入，当作为函数参数传递时，就无需考虑值传递和地址传递的问题了，无论是主调函数还是被调函数，使用的都是实参本身

#include <iostream>using namespace std;
// 定义功能1函数
void fun1(int m, int n)
{// 定义交换变量int temp = m;m = n;n = temp;cout << "fun1:: m = " << m << "  n = " << n << endl; // 1314  520
}// 定义功能函数2
void fun2(int *p, int *q)
{int *temp;temp = p;p = q;q = temp;cout << "fun2:: *p = " << *p << "  *q = " << *q << endl; // 1314  520
}// 定义功能函数3
void fun3(int *p, int *q)
{int temp;temp = *p;*p = *q;*q = temp;cout << "fun3:: *p = " << *p << "  *q = " << *q << endl; // 1314  520
}// 定义功能函数4
void fun4(int &m, int &n)
{// 定义交换变量int temp = m;m = n;n = temp;cout << "fun4:: m = " << m << "  n = " << n << endl; // 520 1314
}int main()
{int m = 520;int n = 1314;// 调用交换函数 传递值  --->  值传递fun1(m, n);cout << "main :: m = " << m << "  n = " << n << endl; // 520 1314// 调用交换函数 传递地址 --->  值传递fun2(&m, &n);cout << "main :: m = " << m << "  n = " << n << endl; // 520 1314// 调用交换函数 传递地址  ---> 地址传递fun3(&m, &n);cout << "main :: m = " << m << "  n = " << n << endl; // 1314 520// 调用交换函数 传递值  --->  地址传递fun4(m, n);cout << "main :: m = " << m << "  n = " << n << endl; // 520 1314return 0;
}

6.5 引用做返回值

1. 普通数据的返回是值返回，只能做右值使用

2. 引用可以作为函数的返回值，引用函数可以做左值使用

3. 引用函数必须返回生命周期比较长的内存空间

   1.全局变量

   2.静态局部变量

   3.堆区空间中的内存

   4.主调函数通过地址传递进来的形参的空间

#include <iostream>using namespace std;// 定义功能函数，返回值为普通值
int fun1()
{int m = 520;return m;
}// 定义功能函数，返回地址
int *fun2()
{static int num = 520;return &num;
}// 定义功能该函数，返回变量的引用
int &fun3()
{static int num = 520;return num;
}int main()
{int ret1 = fun1();cout << "ret1 = " << ret1 << endl; // 520// fun1() = 1314;        //值返回的函数，只能做右值int *ret2 = fun2();cout << "*ret2 = " << *ret2 << endl; // 520*fun2() = 1314;cout << "*ret2 = " << *ret2 << endl;     // 1314cout << "*fun2() = " << *fun2() << endl; // 1314///int ret3 = fun3();cout << "ret3 = " << ret3 << endl; // 520int &ret4 = fun3();cout << "ret4 = " << ret4 << endl; // 520fun3() = 666; // 引用函数可以作为左值使用cout << "fun3() = " << fun3() << "  ret4 = " << ret4 << "  ret3 = " << ret3 << endl;return 0;
}

6.6 常引用const

1. const修饰的成员，为了保护数据不被修改

2. const修饰引用，不能通过引用名改变目标的值，但是可以通过目标本身进行改变

3. 定义格式：const 数据类型 &引用名 = 引用目标；

#include <iostream>using namespace std;int main()
{int num = 520;const int &r = num;cout << "r = " << r << endl; // 可以读取数据 520// r = 1314;              //不可更改内容num = 1314;cout << "r = " << r << endl; // 1314const double &f = num;// 不同类型的引用一般不能将其他类型的变量作为引用的目标// 如果非要将其设为引用目标，则要将该引用设置成常引用// 常引用，既可以引用左值也可以引用右值return 0;
}

6.7 结构体中的引用成员

#include <iostream>using namespace std;struct Stu
{string name ;int age ;double &score ;
};int main()
{//struct Stu s1;          //如果结构体中无引用成员，则直接使用double s = 99;struct Stu s1 = {"李四", 20, s};   //结构体中有引用成员时，必须对其进行初始化return 0;
}

七、引用和指针的区别（笔试面试题）(重点)

1. 引用不占用内存空间，引用的空间和目标一致，但是指针分配8字节内存

2. 定义引用时必须初始化，而指针不用

3. 引用的目标一旦指定，后期不能更改，但是指针可以

4. 使用指针之前需要进行合法性检查，但是引用不需要

5. 有多级指针，但是没有多级引用

e &score ;
};

int main()
{
//struct Stu s1; //如果结构体中无引用成员，则直接使用
double s = 99;
struct Stu s1 = {“李四”, 20, s}; //结构体中有引用成员时，必须对其进行初始化
return 0;
}

# <font color=red>七、引用和指针的区别（笔试面试题）(重点)</font>1. 引用不占用内存空间，引用的空间和目标一致，但是指针分配8字节内存2. 定义引用时必须初始化，而指针不用3. 引用的目标一旦指定，后期不能更改，但是指针可以4. 使用指针之前需要进行合法性检查，但是引用不需要5. 有多级指针，但是没有多级引用6. 有指针数组，没有引用数组