基础知识+字符串string类

技术探索
🗨️字数统计=1.9k字 ⏳阅读时长≈7分钟

一、面向对象/过程

1. 面向过程过程

img

优点：

有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护

缺点：

  • 可重用性差、数据安全性差、难以开发图形界面的应用
  • 把数据和处理数据的过程分离为相互独立的实体。
  • 当数据结构改变时，所有相关的处理过程都要进行相应的修改。
  • 每一种相对于老问题的新方法都要带来额外的开销。
  • 图形用户界面的应用，很难用过程来描述和实现，开发和维护都很困难。

2. 面向对象编程

img

面向对象的基本概念

  • 对象
  • 抽象与分类
  • 封装
  • 继承
  • 多态

img

优点：

  • 程序模块间的关系更为简单，程序模块的独立性、数据的安全性就有了良好的保障。
  • 通过继承与多态性，可以大大提高程序的可重用性，使得软件的开发和维护都更为方便。

二、C++语言基础

1. 信息的存储单位

img

2. 命名空间

img

若没有using namespace std 则： cout << 改为 std :: cout <<

3. 基本数据类型 + 字符串

C++的基本数据类型

  • bool
  • char(字符类型)
  • int
  • float
  • double

注： 基本数据类型中没有字符串类型（string）

一对 “ ” 括起来的字符序列表示 字符串（在末尾添加’\0’作为结尾标记），

‘ ' 括起来的表示 单个字符

img

字符串处理

C++基本数据类型中没有字符串变量，存储和处理方法有两种如下：

  1. 用字符数组来存放字符串；（C风格字符串）
    img
  2. 标准C++库预定义 string 类
    img
    img

4. string 类详解

string类是一个模板类，它的定义如下：

1
typedef basic_string string

4.1 string类的初始化

• string s1("Hello"); //一个参数的构造函数，用Hello初始化

• sting s2(5,'x'); //两个参数的构造函数，5代表x出现的次数

• string month = "March";

不提供以字符和整数为参数的构造函数

  • string error1 = 'c'; //error
  • string error2 = ('u'); //error
  • string error3 = 22; //error
  • string error4(8); //error

可以将字符赋值给string对象

1
2
string s;
s = 'n';

4.2 string 的赋值和连接

① 赋值

  • 用 = 赋值

    1
    2
    string s1("cat"), s2;
    s2 = s1;

  • 用 assign 成员函数复制

    1
    2
    string s1("cat"),s2;
    s2.assign(s1); //s1赋值给s2

  • 用assign成员函数部分复制

    1
    2
    string s1("cat"),s2;
    s2.assign(s1,1,3); //从s1的下标为1的字符开始复制3个字符给s2

  • 单个字符复制

    1
    s2[4] = s1[3];

  • 使用 at 成员函数逐个访问 string 对象中的字符

    1
    2
    3
    string s1 = "hello";
    for(int i = 0; i<s1.length();i++)
        cout<< s1.at(i) <<endl;

🚥 注：成员函数 at 会做下标范围检查，若果超出范围会抛出 out_of_range 异常，而下标运算符不做范围检查

② 连接

  • 用 + 连接字符串

    1
    2
    3
    string s1("good"),s2("morning!");
    s1 += s2;
    cout<<s1;

  • 用成员函数 append 连接

    1
    2
    3
    4
    5
    s1.append(s2);
    s2.append(s1,3,s1.size()); 
    //s1.size()  s1的字符数
    //从s1的下标3开始，连接s1.size()个的字符
    //若字符串内没有足够字符，则复制到s1的末尾就停止

4.3 常用方法

长度 length() / size()

构造的string太长无法表达 -> 会抛出 length error 异常

1
s.length() / s.size()

子串 substr()

成员函数 substr()

1
s2 = s1.substr(3,2); //下标3开始2个字符

寻找字符 find()

  • 成员函数 find()

    1
    2
    3
    4
    5
    6
    s1.find("lo");
    //从s1中从前往后找lo第一次出现的位置，返回l所在的位置下标
    //若没有找到，返回string::npos（string中定义的静态常量）
    s1.rfind("lo");
    //从后往前查找，返回l的位置
    s1.find("a",2); //从下标2开始查找“a"

  • 成员函数 find_first_of()
    查找字符第一次出现的下标

  • 成员函数 find_last_of()
    查找字符最后一次出现的地方

消除 erase()

1
s1.erase(3); //返回 消除下标3及以后的字符串

替换 replace()

1
2
s1.replace(2,3,"hala",1,2);
//将s1中下标从2开始的3个字符 替换成 "hala"中从下标1开始的2个字符

插入 insert()

1
2
s1.insert(4,s2); //将s2插入s1下标为4的位置
s1. insert(2,s2,5,3) //将s2中下标5开始的3个字符插入s1下标为2的位置

转换成C语言形式char*字符串 c_str()

1
2
3
s1.c_str();
//返回传统的const char*类型字符串
//且该字符串以'\0'结尾

5. 运算

此处就不详细解释了，就挑出了一些容易混淆的地方

当 / 用于两个整型数据相除时，其结果取商的整数部分，小数部分被自动舍弃。

int a = 1/2 —-> a = 0;

逗号运算

1
a=3*5, a*4;

—->结果为第二个表达式的值60

逻辑运算

&& 和 || 具有短路特性。

  • 对于&&，如果第一个表达式为false，则不再对第二个表达式求值；
    （因为无论第二个表达式为多少最后结果都为false）
  • 对于||，如果第一个表达式为true,则不再对第二个表达式求值；
    (a==b) || (++c == 1) 这个表达式中c的自增只有在a!=b的时候才会执行

位运算

img img

sizeof 运算

img

6. 类型转换

隐含类型转换

img

赋值运算要求左值与右值的类型相同，若类型不同，编译系统会自动将右值转换为左值的类型。

ex:

1
2
3
4
float fval;
double dval;
unsigned long ulval;
dval = ulval + fval;  //ulval被转换为float类型,加法运算的最终结果被转化为double

显示类型转换

img

float z;强制类型转换int(z)只是将float类型变量z临时取出来转换为int型，

这时变量z所在的内存单元中的值并未真正改变。


三、算法的基本控制结构

  • if语句 （选择结构）
    img
  • switch语句（选择结构）
  • while语句（循环结构）
  • do while语句（循环结构）
    img
  • for语句（循环结构）
  • 其他控制语句
    img

四、enum 枚举类型

语法形式： enum 枚举类型名 {变量值列表};

例：enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT};

默认情况下 SUN=0，MON=1，TUE=2，……，SAT=6

img

img

ex： 口袋中有红、黄、蓝、白、黑五种颜色的球若干个。每次从口袋中取出3个不同颜色的球，问有多少种取法。

分析： 由于球只能是五种颜色之一，故可用枚举类型表示球的颜色。

设取出的球为 i、j、k，根据题意，i、j、k分别可以有五种取值，且i≠j≠k。

可以用穷举法，逐个检验每一种可能的组合，从中找出符合要求的组合并输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
int main()
{
    enum color{red,yellow,blue,white,black};
    color pri; //enum color pri;
    int n = 0;     //一共有多少种情况
    for (int i = red; i <= black; i++)
        for (int j = red; j <= black; j++)
            if (i != j)
            { //前两个球颜色不同
                for (int k = red; k <= black; k++)
                    if (k != i && k != j)
                    {
                        n = n + 1;
                        cout.width(4);
                        cout << n;
                        
                        //以下代码为输出所有组合，解题核心是上面的三层嵌套循环
                        for (int loop = 1; loop <= 3; loop++)
                        {
                            switch (loop)
                            {
                            case 1:
                                pri = color(i); // (enum color) i
                                break;
                            case 2:
                                pri = color(j);
                                break;
                            case 3:
                                pri = color(k);
                                break;
                            default:
                                break;
                            }
                            switch (pri)
                            {
                            case red:
                                cout << "   red";
                                break;
                            case yellow:
                                cout << "   yellow";
                                break;
                            case blue:
                                cout << "   blue";
                                break;
                            case white:
                                cout << "   white";
                                break;
                            case black:
                                cout << "   black";
                                break;
                            default:
                                break;
                            }
                        }
                        cout << endl;
                    }
            }
    cout << n;
    return 0;
}
分享到