C++学习（day2）

最新推荐文章于 2024-09-28 15:28:59 发布

m0_37565374

最新推荐文章于 2024-09-28 15:28:59 发布

阅读量545

点赞数

分类专栏： # C++ 文章标签： c++ 学习算法

本文链接：https://blog.csdn.net/m0_37565374/article/details/130253479

版权

C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

四. C++中的字符串
五、bool类型
六、引用（reference）
七、引用和指针的区别（笔试面试题）(重点)

四. C++中的字符串

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

C语言风格的字符串依然支持，使用字符数组的形式存储字符串，字符串标志：‘\0’
C++风格的字符串，本质上是string类的对象

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

4.2 string类型的赋值和初始化

单个数据的初始化和赋值

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

多个数据的初始化和赋值

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

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

C风格的字符串可以无条件转换为C++风格字符串，原因是C++兼容C的语法
C++风格的字符串转换为C风格字符串需要调用成员函数：c_str（）、data()

方式 C++风格字符串转换为c风格字符串调用成员函数
strcpy(s1,s2.c_str()); s2.c_str()
strcpy(s1, s2.data()); s2.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类型的比较

string类型的比较，可以直接使用关系运算符进行比较(如: < > ==)
而C风格的字符串比较只能使用strcmp函数来完成

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

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

6.8 string类型数据的输入

不带空格的输入：cin
带空格的输入：getline()

五、bool类型

C语言不支持bool类型，但是C++支持
bool类型的值只有两个：true(非0数字)、false(0)
true和false这两个属于关键字，是真和假的常量，不可用做标识符
bool类型的数据，默认使用数字表示真假，如果想要使用单词表示真假，则需要加上boolalpha，在此之后全部都使用单词表示

如果想要继续使用数字表示真假，则需要加上noboolalpha即
bool类型所占内存大小为1字节，原则上只需要使用1位即可，但是，计算机分配资源的基本单位为字节，所以，给bool类型分配1字节大小空间

六、引用（reference）

6.1 引用概念

引用是C++对C的非常重要的扩充
作用：相当于给变量的内存空间重新起个别名。例如，宋江别名：及时雨、孝义黑三郎

6.2 定义引用

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

举个例子：

int num = 520;

int &r = num; //此时变量r和变量num是同一个内存空间的两个名字（左值引用）
总结==&==的用途
- 两个&表示逻辑与运算
- 作为位运算，一个&表示按位与运算
- 作为取地址运算符，一个&表示取得变量的内存地址
- 定义引用时，是身份的象征，表明定义的是引用变量
左值和右值

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

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

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

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

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

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

6.3 引用的基本使用

#include <iostream>

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

    return 0;
}

6.5 引用做返回值

普通数据的返回是值返回，只能做右值使用
引用可以作为函数的返回值，引用函数可以做左值使用
引用函数必须返回生命周期比较长的内存空间

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

const修饰的成员，为了保护数据不被修改
const修饰引用，不能通过引用名改变目标的值，但是可以通过目标本身进行改变
定义格式：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; // 1314

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

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

引用不占用内存空间，引用的空间和目标一致，但是指针分配8字节内存
定义引用时必须初始化，而指针不用
引用的目标一旦指定，后期不能更改，但是指针可以
使用指针之前需要进行合法性检查，但是引用不需要
有多级指针，但是没有多级引用

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. 有指针数组，没有引用数组