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 

using namespace std;

int main()
{
    int num = 520; // 在内存空间随机申请4字节，存放520，内存名字叫num

    // 定义引用目标为num
    int &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; // i

    int key = 1314;

    r = key;                                                                // 该语句合法，但是不是将引用改变目标，而是将key值赋值给r
    cout << "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 

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 1314

    return 0;
}

6.5 引用做返回值

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

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

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

   1.全局变量

   2.静态局部变量

   3.堆区空间中的内存

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

#include 

using namespace std;

// 定义功能函数，返回值为普通值
int fun1()
{
    int m = 520;

    return m;
}

// 定义功能函数，返回地址
int *fun2()
{
    static int num = 520;

    return #
}

// 定义功能该函数，返回变量的引用
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;     // 1314
    cout << "*fun2() = " << *fun2() << endl; // 1314

    ///
    int ret3 = fun3();
    cout << "ret3 = " << ret3 << endl; // 520
    int &ret4 = fun3();
    cout << "ret4 = " << ret4 << endl; // 520

    fun3() = 666; // 引用函数可以作为左值使用
    cout << "fun3() = " << fun3() << "  ret4 = " << ret4 << "  ret3 = " << ret3 << endl;

    return 0;
}

6.6 常引用const

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

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

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

#include 

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; // 1314

    const double &f = num;
    // 不同类型的引用一般不能将其他类型的变量作为引用的目标
    // 如果非要将其设为引用目标，则要将该引用设置成常引用
    // 常引用，既可以引用左值也可以引用右值

    return 0;
}

6.7 结构体中的引用成员

#include 


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;
}

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

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

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

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

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

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

6. 有指针数组，没有引用数组