如何读入 形如2,1,+,3,*到vector<string>类型的数组里

在C++中，如果你想要将形如 "2,1,+,3,"* 这样的字符串组成的数组读入到 `std::vector<std::string>` 中，你可以按照以下步骤操作：

1. 首先，创建一个空的 `vector` 来存储字符串：

   std::vector<std::string> expression;

2. 然后，假设你有一个包含这些字符串的数组或其他数据源，例如 `std::array<std::string, N>` 或者从文件、用户输入等获取：

   // 假设 input_array 是包含待读取元素的数组
   const std::array<std::string, N> input_array = {"2", "1", "+", "3", "*"};

3. 使用一个循环将 `input_array` 的内容逐个添加到 `expression` 中：

   for (const auto &str : input_array) {
       expression.push_back(str);
   }

4. 现在，`expression` 就包含了你的字符串数组：

   std::cout << "Expression vector: ";
   for (const auto &s : expression) {
       std::cout << s << ' ';
   }

相关问题

#include <iostream> #include <algorithm> #include <cstdio> #include <cmath> #include <vector> #include <map> #include <string> #include <cstring> #define fast ios::sync_with_stdio(false),cin.tie(0) using namespace std; typedef pair<int, int> PII; typedef long long LL; const int N = 1010; int T; int f1, s1, f2, s2; vector<PII> v; string x[8] = {"11111111", "10000001", "10111101", "10111101", "10111101", "10111101", "10000001", "11111111"}; int main() { int n, m; scanf("%d %d", &n, &m); string s[N]; for(int i = 0; i < n; i ++ ) { cin >> s[i]; } for(int i = 0; i <= n - 8; i ++ ) { for(int j = 0; j <= m - 8; j ++ ) { int k, cnt = 0; for(k = 0; k < 8; k ++ ) { //cout << k << " " << x[k] << " " << s[i+k].substr(j, 8) << endl; if( x[k] == s[i+k].substr(j, 8) ) cnt ++; } if(cnt == 8) v.push_back({i, j}); } } sort(v.begin(), v.end()); for(int i = 0; i < 3; i ++ ) printf("%d %d\n", v[i].first, v[i].second); return 0; }

这是一段 C++ 代码，可能是用于解决某个问题的。下面是代码的大致功能：

1. 读入两个整数 n 和 m（n 和 m 分别表示一个矩阵的行数和列数）。
2. 读入一个字符串数组 s，长度为 n，每个元素为长度为 m 的字符串。
3. 定义一个字符串数组 x，长度为 8，每个元素为长度为 8 的字符串。
4. 遍历 s 数组，对于每个 8 x 8 的子矩阵，判断其是否与 x 数组中的某个元素相同，如果是，则将该子矩阵的左上角坐标记录下来。
5. 对所有符合条件的子矩阵的左上角坐标按照从上到下、从左到右的顺序进行排序。
6. 输出排序后前三个子矩阵的左上角坐标。

具体来说，这个代码可能是用于在一个黑白矩阵中寻找所有的 8 x 8 矩阵中的黑白图案是否与预设的 8 个黑白图案相同，如果相同则记录下来该 8 x 8 矩阵的左上角坐标，并按照从上到下、从左到右的顺序输出前三个符合条件的矩阵的左上角坐标。

对此代码进行优化#include <iostream> #include <vector> using namespace std; // 求最大公约数 int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } // 获取所有分母小于等于 n 的最简分数 vector<pair<int, int>> getFractions(int n) { vector<pair<int, int>> res; // 存储最简分数的数组 for (int i = 2; i <= n; i++) { // 枚举分母 i for (int j = 1; j < i; j++) { // 枚举分子 j if (gcd(i, j) == 1) { // 判断是否为最简分数 res.push_back({j, i}); // 存储最简分数 } } } return res; } int main() { int n; while (cin >> n && n != 0 && n<=100) { // 循环读入每个正整数 vector<pair<int, int>> res = getFractions(n); // 求解最简分数 for (auto p : res) { // 遍历最简分数数组 cout << p.first << "/" << p.second << " "; // 输出最简分数 } cout << endl; } return 0; }

对于这段代码，可以进行如下优化：

1. 在判断是否为最简分数时，可以将判断i和j是否互质的操作提取出来，使用一个单独的函数进行判断，可以减少gcd函数的调用次数。

2. 对于每个正整数n，可以使用一个数组存储小于等于n的所有质数，然后在判断i和j是否互质时，只需要判断j是否为n以内的质数即可，因为i已经是n以内的数，只有当j为质数时才有可能是最简分数，因此不需要枚举所有的j。

3. 在输出最简分数时，可以使用字符串流stringstream，将分子和分母转换成字符串后拼接输出，可以避免使用多个输出操作符<<。

优化后的代码如下所示：

#include <iostream>
#include <vector>
#include <sstream>
#include <cmath>

using namespace std;

// 判断两个数是否互质
bool isCoprime(int a, int b) {
    return gcd(a, b) == 1;
}

// 获取所有分母小于等于 n 的最简分数
vector<pair<int, int>> getFractions(int n) {
    vector<pair<int, int>> res;  // 存储最简分数的数组 
    vector<int> primes;  // 存储小于等于n的所有质数 
    primes.push_back(2);  // 2是第一个质数 
    for (int i = 3; i <= n; i++) {
        bool isPrime = true;
        for (auto p : primes) {
            if (p > sqrt(i)) {
                break;
            }
            if (i % p == 0) {
                isPrime = false;
                break;
            }
        }
        if (isPrime) {
            primes.push_back(i);
        }
    }
    for (int i = 2; i <= n; i++) {  // 枚举分母 i 
        for (auto p : primes) {
            if (p > i) {
                break;
            }
            if (i % p == 0) {
                goto next_i;  // i不是质数，跳过 
            }
        }
        for (int j = 1; j < i; j++) {  // 枚举分子 j 
            if (j > n || !isCoprime(i, j)) {
                continue;
            }
            res.push_back({j, i});  // 存储最简分数
        }
        next_i:
        continue;
    }
    return res;
}

int main() {
    int n;
    while (cin >> n && n != 0 && n <= 100) {  // 循环读入每个正整数
        vector<pair<int, int>> res = getFractions(n);  // 求解最简分数
        for (auto p : res) {  // 遍历最简分数数组
            stringstream ss;
            ss << p.first << "/" << p.second << " ";
            cout << ss.str();  // 输出最简分数
        }
        cout << endl;
    }
    return 0;
}

经过优化后，代码的可读性和执行效率都得到了提高。