C++中string是浅拷贝还是深拷贝

在C++中，`std::string`是深拷贝（deep copy）的。当你将一个`std::string`对象赋值给另一个`std::string`对象时，会发生深拷贝，即会复制原字符串的内容到新的字符串对象中，而不是仅仅复制指针。这意味着，如果你修改其中一个`std::string`对象中的内容，不会影响到其他对象中的内容。

例如，考虑以下代码：

std::string str1 = "hello";
std::string str2 = str1; // 深拷贝
str1[0] = 'H';
std::cout << str1 << std::endl; // 输出 "Hello"
std::cout << str2 << std::endl; // 输出 "hello"

在这个例子中，`str2`的值是从`str1`拷贝而来的，但是当我们修改`str1`中的第一个字符时，`str2`并没有受到影响，因为它们是两个独立的对象，拥有自己的内存空间。

相关问题

c++深拷贝何浅拷贝

C++中的深拷贝和浅拷贝是指在对象拷贝时，是否仅仅是拷贝了指针或引用，还是拷贝了指针或引用所指向的对象。具体来说，浅拷贝只是简单的指针或引用拷贝，两个对象指向同一块内存地址，修改其中一个对象的值会影响另一个对象的值。而深拷贝则是在堆内存中重新申请空间，将原对象的值复制到新的内存空间中，两个对象的内存地址不同，修改其中一个对象的值不会影响另一个对象的值。

下面是一个C++类的例子，演示了深拷贝和浅拷贝的区别：

#include <iostream>
#include <cstring>

using namespace std;

class String {
public:
    String(const char* str = "") {
        if (str == nullptr) {
            m_data = new char[1];
            *m_data = '\0';
        } else {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
    }

    // 拷贝构造函数
    String(const String& other) {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
    }

    // 赋值运算符重载
    String& operator=(const String& other) {
        if (this != &other) {
            char* temp = new char[strlen(other.m_data) + 1];
            strcpy(temp, other.m_data);
            delete[] m_data;
            m_data = temp;
        }
        return *this;
    }

    ~String() {
        delete[] m_data;
    }

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

private:
    char* m_data;
};

int main() {
    String str1("hello");
    String str2 = str1; // 浅拷贝
    String str3("world");
    str3 = str1; // 深拷贝

    str1.print(); // 输出：hello
    str2.print(); // 输出：hello
    str3.print(); // 输出：hello

    str2 = "world";
    str1.print(); // 输出：world
    str2.print(); // 输出：world
    str3.print(); // 输出：hello
    return 0;
}

c++浅拷贝和深拷贝的例子

浅拷贝和深拷贝是在C++中涉及对象拷贝构造函数和赋值运算符重载的概念。

浅拷贝是指将对象的成员变量简单地逐位复制到另一个对象，这会导致两个对象的成员变量共享同一块内存。而深拷贝则是创建一个新的对象，并将原对象的成员变量逐位复制到新对象中，两个对象的成员变量分别占用不同的内存空间。

下面是一个示例代码：

#include <cstring>

class String {
private:
 char* data;
 int size;

public:
 // 构造函数 String(const char* str) {
 size = strlen(str);
 data = new char[size +1];
 strcpy(data, str);
 }

 // 拷贝构造函数 String(const String& other) {
 size = other.size;
 data = new char[size +1];
 strcpy(data, other.data);
 }

 // 赋值运算符重载 String& operator=(const String& other) {
 if (this == &other) {
 return *this;
 }

 delete[] data;
 size = other.size;
 data = new char[size +1];
 strcpy(data, other.data);

 return *this;
 }

 // 析构函数 ~String() {
 delete[] data;
 }

 void print() {
 std::cout << data << std::endl;
 }
};

int main() {
 String str1("Hello");
 String str2 = str1; // 浅拷贝 String str3("World");
 str3 = str1; // 深拷贝 str1.print(); // 输出 "Hello"
 str2.print(); // 输出 "Hello"
 str3.print(); // 输出 "Hello"

 return0;
}

在上面的示例中，`String` 类包含了一个字符数组 `data` 和一个整数 `size`，用于存储字符串和字符串长度。在构造函数中，我们使用 `new` 运算符为 `data` 动态分配内存，并将传入的字符串复制到 `data` 中。在拷贝构造函数中，我们也是通过动态分配内存并复制成员变量来实现拷贝。在赋值运算符重载函数中，我们首先释放原有的内存，然后再进行深拷贝。

在 `main` 函数中，我们创建了三个 `String` 对象：`str1`、`str2` 和 `str3`。其中，`str2` 是通过拷贝构造函数进行浅拷贝得到的，而 `str3` 是通过赋值运算符重载进行深拷贝得到的。最后，我们分别打印了三个对象的内容，可以看到浅拷贝的对象共享同一块内存，而深拷贝的对象拥有独立的内存空间。