力扣 螺旋矩阵-54

螺旋矩阵-54

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size(),n = matrix[0].size();//数组的行列大小
        int top=0,down=m-1,left = 0,right = n-1;//分别为矩阵上下左右的边界
        int index = 0;//存放结果数组的索引
        vector<int>nums(m*n);//用来存放结果
        while(index<m*n)
        {
            for(int i = left;i<=right;i++)//向右遍历
            {
                nums[index++] = matrix[top][i];
            }
            ++top;//向右遍历之后矩阵当前层最上面一行就不需要再遍历，所以++top
            for(int i = top;i<=down;i++)//向下遍历
            {
                nums[index++] = matrix[i][right];
            }
            --right;//向下遍历之后矩阵当前层最右面一行就不需要再遍历，所以--right
            if(top<=down)//不加if判断的话就会发生重遍历或者访问越界错误
            {
                for(int i = right;i>=left;i--)//向左遍历
                {
                nums[index++] = matrix[down][i];
                }
                --down;//向左遍历之后矩阵当前层最下面一行就不需要再遍历，所以--down
            }
            if(left<=right)//不加if判断的话就会发生重遍历或者访问越界错误
            {
                for(int i = down;i>=top;i--)//向上遍历
                {
                nums[index++] = matrix[i][left];
                }
                ++left;//向上遍历之后矩阵当前层最左面一行就不需要再遍历，所以++left
            }
            
        }
        return nums;
    }
};

每日问题

什么是封装性？C++中如何实现封装？ 封装性的好处是什么？

什么是封装性？

封装（Encapsulation）是面向对象编程（OOP）的四大基本特性之一，指的是将数据（成员变量）和操作数据的方法（成员函数）结合在一起，并对外界隐藏数据的具体实现细节，只暴露接口供外界访问和操作。

简单来说，封装就是“把数据和操作数据的代码捆绑在一起，并通过公开的接口与外界进行交互”。它帮助隐藏对象的内部实现细节，使得外部只能通过提供的接口与对象交互，而不能直接访问对象的内部数据。

C++中如何实现封装？

C++通过使用类（class）和访问控制修饰符（如 private、protected 和 public）来实现封装。

        1.private: 该访问控制修饰符下的成员只能被类的成员函数访问，不能被类外部的代码直接访问。

        2.protected: 该访问控制修饰符下的成员可以在类的成员函数中访问，也可以在继承该类的派生类中访问。

        3.public: 该访问控制修饰符下的成员可以被任何外部代码访问。

通过将数据成员设为 private，并通过 public 成员函数访问和修改这些数据成员，C++ 实现了封装性。

示例代码：

#include <iostream>
using namespace std;

class BankAccount {
private:
    // 账户余额是私有的，外部无法直接访问
    double balance;

public:
    // 构造函数初始化余额
    BankAccount(double initialBalance) {
        if (initialBalance >= 0)
            balance = initialBalance;
        else
            balance = 0;
    }

    // 公共方法，用于存款
    void deposit(double amount) {
        if (amount > 0)
            balance += amount;
        else
            cout << "Deposit amount must be positive!" << endl;
    }

    // 公共方法，用于取款
    void withdraw(double amount) {
        if (amount > 0 && amount <= balance)
            balance -= amount;
        else
            cout << "Invalid withdrawal amount!" << endl;
    }

    // 公共方法，用于获取余额
    double getBalance() const {
        return balance;
    }
};

int main() {
    BankAccount account(1000);  // 创建账户并初始化余额为1000

    cout << "Initial balance: " << account.getBalance() << endl;

    account.deposit(500);  // 存款500
    cout << "After deposit: " << account.getBalance() << endl;

    account.withdraw(200);  // 取款200
    cout << "After withdrawal: " << account.getBalance() << endl;

    account.withdraw(1500);  // 试图取款超过余额
    cout << "After invalid withdrawal: " << account.getBalance() << endl;

    return 0;
}

在上面的代码中：

balance 是私有的 (private)，外部代码无法直接修改账户余额。

deposit()、withdraw() 和 getBalance() 是公有的 (public)，外部可以通过它们访问和修改余额。

通过 deposit() 和 withdraw() 控制存款和取款的逻辑，从而避免了不合法的操作（例如取款超过余额）。

封装性的好处：

1.数据隐藏（信息隐藏）：

封装使得对象的内部实现细节对外部隐藏，外部无法直接访问和修改对象的状态。这可以防止外部代码直接改变对象的关键数据，保护数据的安全性。

2.提高代码的安全性：

通过封装，开发人员可以确保数据只能通过特定的方法访问或修改，避免了错误的操作（例如直接修改余额）导致程序出现不可预测的行为。

3.代码的可维护性和可扩展性：

封装使得类的实现细节与外部代码解耦。这样，修改类的内部实现时，外部代码不需要做修改，只要接口不变，外部代码可以继续工作。因此，封装有助于提升代码的可维护性和可扩展性。

4.减少代码耦合：

外部代码只能通过类提供的公有接口与对象交互，减少了外部对内部实现的依赖，从而减少了代码耦合度，增加了系统的灵活性。

5.易于调试和测试：

由于类的内部数据不被外部直接访问，数据的访问和修改通过公有函数进行，可以方便地在函数内部加入检查机制，保证数据的有效性和正确性。同时，封装也便于对类进行单元测试。

6.抽象性增强：

封装是面向对象的另一项基本特性，它增强了抽象性。通过封装，外部系统只需要关注如何使用类的接口，而不需要了解类的内部实现，进一步增强了代码的抽象性。

总结：

封装是面向对象编程的重要特性，它通过将数据和方法封装在类中，保护数据的安全性、提升代码的可维护性与可扩展性。C++通过访问控制修饰符（private、protected 和 public）实现封装，封装带来的好处包括信息隐藏、数据安全性、代码的可维护性和灵活性等。

原文地址：https://blog.csdn.net/Sunyanhui1/article/details/144377088

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！