如何用字符串 str2 的子串去初始化 str1；str2: Hello

可以使用 `string` 类的构造函数以及 `substr` 方法来实现。`substr` 方法可以从一个字符串中截取一段子串。

例如，下面的代码演示了如何使用 `substr` 方法和 `string` 构造函数来从字符串 `str2` 中截取子串并用它来初始化字符串 `str1`。

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str2 = "Hello";
    string str1(str2.substr(0, 3));  // 使用 str2 的子串 "Hel" 初始化 str1
    cout << "str1: " << str1 << endl;
    cout << "str2: " << str2 << endl;

    return 0;
}

运行上面的代码，输出将会是：

str1: Hel
str2: Hello

可以看到，`str1` 被成功初始化为 `str2` 的子串 "Hel"。在 `substr` 方法中，第一个参数是子串的起始位置，第二个参数是子串的长度。

相关问题

问题1：给定两个字符串str1和str2，输出两个字符串的最长公共子串，保证str1和str2的最长公共子串存在且唯一。 要求： （1）数据输入：字符串元素随机生成。 （2）数据输出：最长公共子串。写出c++代码

要解决这个问题，可以使用动态规划的方法来找到两个字符串的最长公共子串。下面是一个C++代码示例：

#include <iostream>
#include <string>

std::string longestCommonSubstring(const std::string& str1, const std::string& str2) {
    int m = str1.length();
    int n = str2.length();
    int dp[m + 1][n + 1];
    int maxLength = 0;
    int endIndex = -1;

    // 初始化动态规划数组
    for (int i = 0; i <= m; ++i) {
        for (int j = 0; j <= n; ++j) {
            if (i == 0 || j == 0)
                dp[i][j] = 0;
            else if (str1[i - 1] == str2[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = 0;

            // 更新最长公共子串信息
            if (dp[i][j] > maxLength) {
                maxLength = dp[i][j];
                endIndex = i - 1;
            }
        }
    }

    // 从右下角回溯构建最长公共子串
    std::string result;
    while (maxLength > 0) {
        result += str1[endIndex];
        maxLength--;
        endIndex--;
    }
    return result; // 反转结果，因为回溯是从右下角开始的
}

int main() {
    std::string str1 = "hello world";
    std::string str2 = "world is beautiful";
    std::cout << "Longest common substring: " << longestCommonSubstring(str1, str2) << std::endl;
    return 0;
}

这段代码首先创建了一个二维动态规划数组`dp`，用于存储每个位置上的最长公共子串长度。然后通过比较字符找出当前位置的最长公共子串长度，并更新最长子串的信息。最后，从最后一个已知的最长公共子串长度的位置回溯，构造出完整的最长公共子串。

定义一个字符串String类。（14分） 包括的属性：一个长度为1000的字符数组； 包括的方法：初始化字符串，求字符串的长度，打印字符串，求字符串位于[a,b]内的子串，连接两个字符串。 输出：主函数中验证各方法的功能。

以下是字符串String类的实现，主函数中也有相应的验证代码：

#include <iostream>
#include <cstring>

using namespace std;

class String {
private:
    char str[1001];

public:
    String() {
        memset(str, 0, sizeof(str));
    }

    String(const char* s) {
        memset(str, 0, sizeof(str));
        strncpy(str, s, 1000);
    }

    int length() {
        return strlen(str);
    }

    void print() {
        cout << str << endl;
    }

    String substr(int a, int b) {
        if (a < 0 || a >= length() || b < 0 || b >= length() || a > b) {
            return String();
        }
        char sub[1001];
        strncpy(sub, str + a, b - a + 1);
        sub[b - a + 1] = '\0';
        return String(sub);
    }

    String operator+(const String& s) {
        String res;
        strncpy(res.str, str, 1000);
        strncat(res.str, s.str, 1000 - strlen(str));
        return res;
    }
};

int main() {
    String s1 = "hello";
    String s2;
    s2 = "world";
    s1.print();
    s2.print();
    cout << "s1 length: " << s1.length() << endl;
    cout << "s2 length: " << s2.length() << endl;
    String s3 = s1.substr(1, 3);
    s3.print();
    String s4 = s1 + s2;
    s4.print();
    return 0;
}