岛屿数量&C++11新特性-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_73301411/article/details/144145042

每日一题

class Solution
{
    //使用深度的优先搜索来搜索岛屿图
    //遍历整个图片 当char数组的值为1时开始从这个点开始往外扩散搜索
    //注意处理边界 图不是正方形
public:
    int ans;
    int d[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    int N;
    int M;
    void dfs(vector<vector<char>> &grid, vector<vector<int>> &vis, int i, int j)
    {
        for (int k = 0; k < 4; k++)
        {
            int nx = i + d[k][0];
            int ny = j + d[k][1];
            if (nx < 0 || nx > N - 1 || ny < 0 || ny > M - 1)
            continue;
            if (!vis[nx][ny]&& grid[nx][ny] != '0')
            {
                vis[nx][ny] = 1;
                dfs(grid, vis, nx, ny);
            }
        }
    }
    int numIslands(vector<vector<char>> &grid)
    {
        ans = 0;
        N = grid.size();
        M = grid[0].size();
        vector<vector<int>> vis(N, vector<int>(M, 0));
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++)
            {
                if (!vis[i][j] && grid[i][j] != '0')
                {
                    ans++;
                    vis[i][j] = 1;
                    dfs(grid, vis, i, j);
                }
            }
        }
        return ans;
    }
};

C++11新特性

自动类型推导（auto 和 decltype）：

在C++中，自动类型推导是通过auto和decltype来实现的。这些关键字让程序员能够在不显式指定类型的情况下，依赖编译器自动推导出变量的类型

auto:

auto关键字用于自动推导变量的类型。编译器根据初始化表达式的类型来推导变量的类型。
它使得代码更加简洁，尤其是在声明复杂类型（如迭代器或lambda表达式）时非常有用。
使用示例：

auto x = 42; // x的类型是int
auto y = 3.14; // y的类型是double
auto ptr = new int(10); // ptr的类型是int*

decltype:

decltype关键字用于推导一个表达式的类型，但与auto不同的是，decltype是在编译时对表达式类型的静态分析，返回的是表达式的实际类型。
它常用于模板编程，或者当你想要获得某个表达式类型但又不确定时非常有用。
使用示例：

int x = 42;
decltype(x) y = 10; // y的类型是int，与x相同

右值引用和移动语义：

右值引用和移动语义是C++11引入的重要特性，用来优化资源管理，尤其是在处理动态分配内存、数组、容器等时，避免不必要的深拷贝。

右值引用:

右值引用是通过&&符号表示的，允许我们绑定到右值（临时对象、即将销毁的对象）上。
在传统的C++中，右值只能绑定到常量或临时变量，但通过右值引用，程序员可以显式地“转移”对象的所有权。
右值引用通常与移动语义一起使用，使得对象的资源（如内存、文件句柄等）能够从一个对象转移到另一个对象，而不是进行深拷贝。
使用示例：

int&& r = 10; // r是右值引用，绑定到临时值10

移动语义:

移动语义允许对象的资源（如内存或文件句柄）在不进行深拷贝的情况下，从一个对象“移动”到另一个对象。
通过实现移动构造函数和移动赋值运算符，C++能够通过右值引用有效地转移资源而不是复制。
在标准库容器（如std::vector、std::string）中，移动语义显著提高了性能，因为容器可以直接将元素从一个容器转移到另一个容器，而不需要复制每个元素。
使用示例：

class MyClass {
public:
    MyClass(int size) : data(new int[size]) {}
    ~MyClass() { delete[] data; }
    
    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(other.data) {
        other.data = nullptr;
    }
    
    // 移动赋值运算符
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
    
private:
    int* data;
};

详解等于号运算符重载实现移动语义

MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {
        delete[] data;            // 1
        data = other.data;        // 2
        other.data = nullptr;     // 3
    }
    return *this;                 // 4
}

1. `if (this != &other)`

这行代码用来确保我们没有将一个对象赋值给它自己。我们需要避免以下的情况：

obj1 = std::move(obj1);  // 这样就会发生自赋值

如果this和&other是相同的（即它们指向的是同一个对象），那么在移动操作时会导致对象的资源被错误地释放，最终使得对象处于不一致的状态。因此，首先通过这个条件判断来确保移动赋值操作不会出现自赋值的情况。

2. `delete[] data;`

这行代码释放当前对象的资源，尤其是类中的动态分配内存（data指针指向的内存）。在进行移动赋值操作时，我们必须释放当前对象的资源，以便为从other对象“移动”资源做好准备。

为什么要释放资源？

在“移动”资源之前，我们需要确保当前对象没有持有相同的资源。假设data指向动态分配的内存，在data = other.data;之后，data和other.data指向同一块内存。如果不释放原有的内存，就会导致内存泄漏，因为对象this和other都持有相同的资源指针，但other指针的析构时会释放这块内存，导致this的指针悬挂，出现不一致的行为。

3. `data = other.data;`

这行代码将other对象的data指针赋给当前对象data，实现资源的“转移”。也就是说，我们把other对象所管理的内存（资源）转移到当前对象this上。other.data指向原来的内存块，而this->data也指向同一块内存块。

此时，this对象就拥有了other对象的资源，other对象中的data指针指向了同样的内存，而other对象的资源将不再有效。

4. `other.data = nullptr;`

在这行代码中，我们将other.data指针置为nullptr。这是为了确保other对象在析构时不会试图释放资源。由于我们已经将other对象的资源转移给了this，other对象不再拥有该资源，因此将other.data置为nullptr可以防止其析构时错误地删除内存。

这一步是移动操作的核心，确保在移动后，other对象不会误操作原本应该由this对象管理的内存，避免多次释放同一块内存。