Eastsheng's Wiki

C&C++笔记-03

2023-01-03 18:11:28

[toc]

常用内置函数用法

最大值、最小值、总和和平均值

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
/*有固定数组，编写程序，输入起始下标i和终止下标j，
求下标在[i,j)之间的元素的最大值、最小值、总和和平均值。平均值为double。
数组元素为{-1,15,-40,-180,99,-122,-124,27,192,128,-165,95,161,-138, -183,51,107,39,-184,113,-63,9,107,188,-11,-13,151,-52,7,6}，元素个数为30个。
输入:两个整数，0<=i,j<=30,两个整数用空格隔开。
输出：最大、最小、总和、平均，用空格隔开，末尾无空格。区间中元素个数为0时（i>=j），输出全0。*/
#include<iostream>
#include<algorithm>
#include<numeric>
using namespace std;
int main(){
    int nums[] {-1,15,-40,-180,99,-122,-124,27,192,128,-165,95,161,-138, -183,51,107,39,-184,113,-63,9,107,188,-11,-13,151,-52,7,6};
    cout<<"有固定数组，编写程序，输入起始下标i和终止下标j"<<endl;
    int a,b;
    cin>>a>>b;
    int c = b - a;
    int sub_num[c];
    if(a>=0&&b<=30){
        for(int i=a; i<b; i++){
            sub_num[i-a] = nums[i];     
        }
    }else{
        cout<<"请输入正确区间！！！"<<endl;
    }
    // for(int j=0; j<c; j++){
    //     cout<<sub_num[j]<<" ";
    // }
    // cout<<endl;
    int max_value = *max_element(sub_num,sub_num+c);
    int min_value = *min_element(sub_num,sub_num+c);
    int sum_value = accumulate(sub_num,sub_num+c,0);
    int ave_value = sum_value/c;
    cout<<max_value<<" "<<min_value<<" "<<sum_value<<" "<<ave_value<<endl;
    return 0;
}

cin用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*编写程序，输入可能带空格的字符串，计算并输入其长度（即字符个数，含空格数）。
字符串最大长度不超过100。使用字符数组实现，不使用字符串库函数。*/
#include<iostream>
using namespace std;
int main(){
    char str[100];
    int n=0;
    cout<<"输入可能带空格的字符串，计算并输入其长度（即字符个数，含空格数）"<<endl;
    cin.get(str,100);
    while(str[n++]){
    }
    cout<<n-1<<endl;

    return 0;
}

大小写

  • cctype库

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include<iostream>
    #include<cctype>
    using namespace std;
    int main(void){
    	char a;
    	cin>>a;
    	if(islower(a))//如果a是小写字母 
    		a=toupper(a);
    	else//a不是小写字母自然就是大写的了，所以就不用再判断了 
    		a=tolower(a);
    	cout<<a;
    }

  • 自己写函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /*
    编写函数，将字符串中的所有字母转换为大写。
    在主函数中定义字符数组，输出字符串，调用函数转大写，在主函数中输出。
    字符串长度不超过200. 注意，必须用字符数组实现，不能使用字符串处理库函数，也不能使用string类。
    */
    #include<iostream>
    using namespace std;

    string AZupper(char *p){
        int i=0;
        while (p[i]>='a' && p[i]<='z'){
            // p[i] = toupper(p[i]);
            p[i] -= 32;
            i++;
        }
        return p;
    }

    int main(){
        char a[200];
        cin.get(a,200);
        cout<<AZupper(a)<<endl;
        return 0;
    }

指针转换为数组

1
2
3
#include <string.h>
memcpy(gr_iframe,gr,sizeof(gr_iframe)); //指针转换为数组
Strcpy(gr_iframe,gr) //指针转换为字符数组

输出数据类型

1
cout<<typeid(gr[i]).name()<<endl;

find_first_of

  • find_first_of是C++标准库中的一个字符串查找函数，用于在目标字符串中查找第一个匹配给定字符集中任何一个字符的位置。它的函数原型为：

    1
    size_t find_first_of(const charT* s, size_t pos, size_t n) const;

  • 其中：

    1
    2
    3
    s：指向要查找的字符集合的字符数组的指针。
    pos：从目标字符串的哪个位置开始查找，默认为0。
    n：字符数组s的长度。

  • 该函数返回目标字符串中第一个匹配字符集合s中任何一个字符的位置。如果找不到任何匹配项，则返回std::string::npos。

  • 以下是一个示例：

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

int main()
{
    std::string str = "Hello, World!";
    std::string chars = "oW";
    size_t pos = str.find_first_of(chars);
    if (pos != std::string::npos)
    {
        std::cout << "Found character '" << str[pos] << "' at position " << pos << std::endl;
    }
    else
    {
        std::cout << "No character found." << std::endl;
    }
    return 0;
}
  • 在上面的示例中，我们定义了一个字符串str和一个包含要查找的字符集的字符串chars。我们使用find_first_of函数在str中查找第一个匹配字符集s中任何一个字符的位置，并将结果存储在pos变量中。如果找到了匹配项，则输出匹配的字符和位置；否则输出一条消息表示没有找到匹配项。

自定义函数

vector拼接函数并调用

  • c++怎么将两个二维的vector拼接，定义成一个函数，并可以调用?
  • 要将两个二维的vector拼接并定义成一个函数，您可以编写一个函数来接收两个二维vector作为参数，并将它们拼接到一个新的vector中。以下是一个示例函数的代码：
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
61
62
63
64
65
66
67
68
#include <iostream>
#include <vector>

// 拼接两个二维vector
std::vector<std::vector<int>> concatenateVectors(const std::vector<std::vector<int>>& v1, const std::vector<std::vector<int>>& v2, bool byRow = true)
{
    std::vector<std::vector<int>> result;
    
    if (byRow)
    {
        // 拼接行
        for (const auto& row : v1)
        {
            result.push_back(row);
        }
        for (const auto& row : v2)
        {
            result.push_back(row);
        }
    }
    else
    {
        // 拼接列
        for (size_t i = 0; i < v1.size(); ++i)
        {
            std::vector<int> row = v1[i];
            row.insert(row.end(), v2[i].begin(), v2[i].end());
            result.push_back(row);
        }
    }
    
    return result;
}

int main()
{
    std::vector<std::vector<int>> v1 {{1, 2}, {3, 4}};
    std::vector<std::vector<int>> v2 {{5, 6}, {7, 8}};
    
    // 拼接行
    std::vector<std::vector<int>> result1 = concatenateVectors(v1, v2);
    
    // 拼接列
    std::vector<std::vector<int>> result2 = concatenateVectors(v1, v2, false);
    
    // 输出结果
    std::cout << "Concatenate by row:" << std::endl;
    for (const auto& row : result1)
    {
        for (const auto& elem : row)
        {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
    
    std::cout << "Concatenate by column:" << std::endl;
    for (const auto& row : result2)
    {
        for (const auto& elem : row)
        {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
    
    return 0;
}

  • 在上面的代码中，我们定义了一个名为concatenateVectors的函数，接受两个二维vector作为参数，并返回拼接后的结果。该函数还接受一个可选的布尔参数，用于指定要按行还是列拼接。默认情况下，函数按行拼接。如果传递false作为第三个参数，则按列拼接。

  • 在main函数中，我们创建了两个二维vectorv1和v2，然后使用concatenateVectors函数分别按行和列拼接这两个vector，并将结果存储在result1和result2中。最后，我们输出拼接后的结果。

删除掉二维vector中每个元素的第一个元素

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
#include <iostream>
#include <vector>

using namespace std;

void delete_first_element(vector<vector<int>>& vec);

int main() {
    vector<vector<int>> vec{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    cout << "Before: " << endl;
    for (auto& inner_vec : vec) {
        for (auto elem : inner_vec) {
            cout << elem << " ";
        }
        cout << endl;
    }

    delete_first_element(vec);

    cout << "After: " << endl;
    for (auto& inner_vec : vec) {
        for (auto elem : inner_vec) {
            cout << elem << " ";
        }
        cout << endl;
    }

    return 0;
}

void delete_first_element(vector<vector<int>>& vec) {
    for (auto& inner_vec : vec) {
        if (!inner_vec.empty()) {
            inner_vec.erase(inner_vec.begin());
        }
    }
}

Tags: C&C++ C&C++初级
← 论文笔记2023-春 编译C++程序：Makefile文件 →