Cpp-Useful-Operations

本博客用来记录基础且好用的cpp功能。

字符串:#

在 C++ 中，字符串处理操作非常丰富，主要依赖于标准库中的 std::string 类。以下是一些常用的字符串处理操作：

1. 创建和初始化字符串#

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <string>

int main() {
    std::string s1;              // 默认构造函数
    std::string s2("Hello");     // 从 C 字符串构造
    std::string s3(s2);          // 拷贝构造函数
    std::string s4(5, 'a');      // 重复字符构造
    std::string s5 = "World";    // 拷贝赋值

    return 0;
}

2. 获取字符串长度#

1
2
std::string s = "Hello";
size_t length = s.length();  // 或者 s.size()

3. 访问和修改字符#

1
2
3
std::string s = "Hello";
char ch = s[1];    // 访问第二个字符
s[1] = 'a';        // 修改第二个字符

4. 拼接字符串#

1
2
3
4
std::string s1 = "Hello";
std::string s2 = "World";
std::string s3 = s1 + " " + s2;  // 使用 + 操作符拼接
s1 += " World";                  // 使用 += 操作符拼接

5. 子字符串#

1
2
std::string s = "Hello, World";
std::string sub = s.substr(7, 5);  // 从第7个位置开始取5个字符

6. 查找字符或子字符串#

1
2
3
std::string s = "Hello, World";
size_t pos = s.find("World");      // 查找子字符串 "World"
pos = s.find('o');                 // 查找字符 'o'

7. 替换子字符串#

1
2
std::string s = "Hello, World";
s.replace(7, 5, "Universe");  // 将 "World" 替换为 "Universe",从index==7的字符开始五个字符被替换

8. 插入和删除字符#

1
2
3
std::string s = "Hello, World";
s.insert(5, ", beautiful");  // 在位置5插入子字符串
s.erase(5, 10);              // 从位置5开始删除10个字符

9. 比较字符串#

1
2
3
4
5
6
7
8
9
std::string s1 = "abc";//自动按照字典序排列
std::string s2 = "xyz";
if (s1 == s2) {
    // 字符串相等
} else if (s1 < s2) {
    // s1 小于 s2
} else {
    // s1 大于 s2
}

10. 转换为 C 字符串#

1
2
std::string s = "Hello";
const char* cstr = s.c_str();  // 返回 C 字符串指针

11. 迭代字符串#

1
2
3
4
std::string s = "Hello";
for (char c : s) {
    std::cout << c << std::endl;
}

12. 转换大小写#

1
2
3
4
5
6
7
8
9
10
#include <algorithm>
#include <cctype>

std::string s = "Hello, World";

// 转换为大写
std::transform(s.begin(), s.end(), s.begin(), ::toupper);

// 转换为小写
std::transform(s.begin(), s.end(), s.begin(), ::tolower);

13. 去除空白字符#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <algorithm> 
#include <cctype> 
#include <locale> 

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

这些是一些常见的字符串操作，C++ 标准库还提供了许多其他有用的函数和方法，可以根据需要进行使用。

排序：#

C++中的std::sort:#

在 C++ 中，标准库提供了std::sort函数用于排序。std::sort 是一个泛型算法，可以用于排序任何支持随机访问迭代器的容器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    // 使用 std::sort 进行排序
    std::sort(vec.begin(), vec.end(), [=](int a,int b){
        return a<b;//输入你希望排序的顺序
    });// 一个lambda表达式；

    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

之后更新一个有关c++技术的理解。

io:#

字符串：#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <string>

int main() {
    std::string str;
    int num;

    // 输入字符串
    std::cout << "Enter a string: ";
    std::getline(std::cin, str); // getline阅读一整行文本，丢弃换行符

    // 输入数字
    std::cout << "Enter a number: ";
    std::cin >> num;

    std::cout << "You entered: " << str << std::endl;
    std::cout << "You entered number: " << num << std::endl;

    return 0;
}

泛型算法：#

自定义：#

在自定义泛型算法的使用时，C++标准库提供了一些方式来扩展和定制算法的功能。你可以通过自定义比较函数、操作函数、和谓词来改变算法的行为。以下是如何自定义这些算法的具体示例：

1. std::sort 自定义排序#

std::sort 允许你提供一个自定义比较函数来指定排序的顺序。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义比较函数：降序排序
bool descending(int a, int b) {
    return a > b;
}

int main() {
    std::vector<int> vec = {4, 1, 3, 2, 5};

    // 使用自定义比较函数进行排序
    std::sort(vec.begin(), vec.end(), descending);

    for (int num : vec) {
        std::cout << num << ' ';
    }
    // 输出：5 4 3 2 1

    return 0;
}

2. std::find 自定义查找条件#

std::find 查找第一个匹配的元素，但你可以使用 std::find_if 提供自定义条件。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义谓词：查找大于3的第一个元素
bool isGreaterThanThree(int x) {
    return x > 3;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用自定义谓词查找
    auto it = std::find_if(vec.begin(), vec.end(), isGreaterThanThree);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << '\n';  // 输出：Found: 4
    } else {
        std::cout << "Not found\n";
    }

    return 0;
}

3. std::transform 自定义操作#

std::transform 可以接受一个自定义操作函数，将其应用于容器中的每个元素。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义操作函数：计算平方
int square(int x) {
    return x * x;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> squared(vec.size());

    // 使用自定义操作函数进行变换
    std::transform(vec.begin(), vec.end(), squared.begin(), square);

    for (int num : squared) {
        std::cout << num << ' ';
    }
    // 输出：1 4 9 16 25

    return 0;
}

4. std::accumulate 自定义累加操作#

std::accumulate 可以接受一个自定义二元操作函数来替代默认的加法操作。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <numeric>
#include <vector>
#include <iostream>

// 自定义累加操作函数：计算乘积
int multiply(int a, int b) {
    return a * b;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用自定义操作函数计算累积乘积
    int product = std::accumulate(vec.begin(), vec.end(), 1, multiply);

    std::cout << "Product: " << product << '\n';
    // 输出：Product: 120

    return 0;
}

5. std::remove_if 自定义删除条件#

std::remove_if 需要一个自定义谓词来决定哪些元素应被移除。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义谓词：移除所有小于3的元素
bool lessThanThree(int x) {
    return x < 3;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用自定义谓词进行移除
    auto it = std::remove_if(vec.begin(), vec.end(), lessThanThree);
    vec.erase(it, vec.end());

    for (int num : vec) {
        std::cout << num << ' ';
    }
    // 输出：3 4 5

    return 0;
}

6. std::for_each 自定义操作#

std::for_each 可以接受一个自定义操作函数来对每个元素执行操作。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义操作函数：打印元素
void print(int x) {
    std::cout << x << ' ';
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用自定义操作函数
    std::for_each(vec.begin(), vec.end(), print);

    return 0;
}

7. std::min_element 和 std::max_element 自定义比较#

std::min_element 和 std::max_element 允许你提供自定义比较函数来决定最小或最大元素。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <algorithm>
#include <vector>
#include <iostream>

// 自定义比较函数：绝对值比较
bool compareAbs(int a, int b) {
    return std::abs(a) < std::abs(b);
}

int main() {
    std::vector<int> vec = {-10, 5, 3, -2, 8};

    // 使用自定义比较函数找到绝对值最小的元素
    auto min_it = std::min_element(vec.begin(), vec.end(), compareAbs);

    std::cout << "Element with minimum absolute value: " << *min_it << '\n';
    // 输出：Element with minimum absolute value: -2

    return 0;
}

其他：#

传参小技巧：#

当你需要限制传入的数组参数的长度时，可以这样写：

1
2
3
int func(int(&arr)[10]){
    /* details */
}

声明成为引用会强制进行长度上的类型检查。