#include <iostream> #include <vector> using namespace std; const int ROWS = 10; // 场景行数 const int COLS = 20; // 场景列数 const int WALL = -1; // 边界标记 vector<vector<int>> scene(ROWS, vector<int>(COLS, 0)); // 场景 void initScene() { for (int i = 0; i < ROWS; i++) { for (int j = 0; j < COLS; j++) { if (i == 0 || i == ROWS - 1 || j == 0 || j == COLS - 1) { scene[i][j] = WALL; // 边界 } } } } void printScene() { for (int i = 0; i < ROWS; i++) { for (int j = 0; j < COLS; j++) { if (scene[i][j] == WALL) { cout << "#"; // 边界符号 } else { cout << " "; // 空白符号 } } cout << endl; } } int main() { initScene(); // 初始化场景 printScene(); // 打印场景 return 0; }这段代码为何在输出屏一直向右输出

这段代码在输出场景时，每行输出完毕后，没有清空输出流。因此，下一次输出时会从上一次输出的位置继续输出，导致输出向右偏移。可以在每行输出完毕后加上 `cout << endl;` 语句，清空输出流，使下一次输出从新的一行开始。修改后的代码如下：

void printScene() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (scene[i][j] == WALL) {
                cout << "#"; // 边界符号
            } else {
                cout << " "; // 空白符号
            }
        }
        cout << endl; // 清空输出流，使下一次输出从新的一行开始
    }
}

相关问题

#include <windows.h> #include <iostream> #include <time.h> using namespace std; struct Cell { char data[128]; }; const int TOTAL_ROWS = 2500; const int TOTAL_COLS = 2500; int main() { clock_t t; t = clock(); Cell* p = (Cell*)malloc(TOTAL_ROWS * TOTAL_COLS * sizeof(Cell)); if (p) { cout << "ok" << endl; } else { cout << "oops" << endl; } (p + (2 * TOTAL_COLS) + 3)->data[0] = 'A'; t = clock() - t; cout << t << endl; t = clock(); p = (Cell*)VirtualAlloc(NULL, TOTAL_ROWS * TOTAL_COLS * sizeof(Cell), MEM_RESERVE, PAGE_READWRITE); if (p) { cout << "ok" << endl; } else { cout << "oops" << endl; } VirtualAlloc(p + (2 * TOTAL_COLS) + 3, sizeof(Cell), MEM_COMMIT, PAGE_READWRITE); (p + (2 * TOTAL_COLS) + 3)->data[0] = 'A'; t = clock() - t; cout << t << endl; return 0; } 在virtual的基础上进行修改，给对角线(左上到右下那条)上所有Cells中的128个元素都赋值成'A'，并用clock函数测量时间。

下面是对代码的修改和解释：

#include <windows.h>
#include <iostream>
#include <time.h>

using namespace std;

struct Cell {
    char data[128];
};

const int TOTAL_ROWS = 2500;
const int TOTAL_COLS = 2500;

int main() {
    clock_t t;
    t = clock();

    // 使用 malloc 分配内存
    Cell* p = (Cell*)malloc(TOTAL_ROWS * TOTAL_COLS * sizeof(Cell));
    if (p) {
        cout << "ok" << endl;
    } else {
        cout << "oops" << endl;
    }

    // 给对角线上的元素赋值为 'A'
    for (int i = 0; i < TOTAL_ROWS && i < TOTAL_COLS; i++) {
        (p + i * TOTAL_COLS + i)->data[0] = 'A';
    }

    t = clock() - t;
    cout << "malloc: " << t << endl;

    t = clock();

    // 使用 VirtualAlloc 分配内存
    p = (Cell*)VirtualAlloc(NULL, TOTAL_ROWS * TOTAL_COLS * sizeof(Cell),
        MEM_RESERVE, PAGE_READWRITE);
    if (p) {
        cout << "ok" << endl;
    } else {
        cout << "oops" << endl;
    }

    // 分配物理内存
    VirtualAlloc(p, TOTAL_ROWS * TOTAL_COLS * sizeof(Cell), MEM_COMMIT, PAGE_READWRITE);

    // 给对角线上的元素赋值为 'A'
    for (int i = 0; i < TOTAL_ROWS && i < TOTAL_COLS; i++) {
        (p + i * TOTAL_COLS + i)->data[0] = 'A';
    }

    t = clock() - t;
    cout << "VirtualAlloc: " << t << endl;

    return 0;
}

上面的修改中，我们在两个内存分配方式中分别给对角线上的元素赋值为 'A'。同时，我们也修改了输出的内容，分别输出使用 malloc 和 VirtualAlloc 分配内存所需的时间。

6-1 矩阵类模板 分数 40 作者 J.Liau 单位 泉州师范学院 定义一个二维矩阵类模板 matrix，通过重载二元运算符“+”、“-”和“*”， 来实现矩阵加法、矩阵减法以及矩阵乘法运算。 完成数组所要求的操作。（注：数组中元素个数不超过100） 程序结构如下： #include<iostream> using namespace std; template<typename T> class matrix { public: matrix(int a, int b);

以下是矩阵类模板 matrix 的完整实现代码：

#include <iostream>
#include <cstring>
using namespace std;

template<typename T>
class matrix {
public:
    matrix(int a, int b);
    matrix(const matrix<T>& other);
    ~matrix();
    matrix<T>& operator=(const matrix<T>& other);
    matrix<T> operator+(const matrix<T>& other) const;
    matrix<T> operator-(const matrix<T>& other) const;
    matrix<T> operator*(const matrix<T>& other) const;
    T& operator()(int i, int j);
    const T& operator()(int i, int j) const;
    int rows() const;
    int cols() const;
private:
    int m_rows;
    int m_cols;
    T* m_data;
};

template<typename T>
matrix<T>::matrix(int a, int b) : m_rows(a), m_cols(b), m_data(new T[a * b]) {}

template<typename T>
matrix<T>::matrix(const matrix<T>& other) : m_rows(other.m_rows), m_cols(other.m_cols), m_data(new T[other.m_rows * other.m_cols]) {
    memcpy(m_data, other.m_data, sizeof(T) * m_rows * m_cols);
}

template<typename T>
matrix<T>::~matrix() {
    delete[] m_data;
}

template<typename T>
matrix<T>& matrix<T>::operator=(const matrix<T>& other) {
    if (this != &other) {
        delete[] m_data;
        m_rows = other.m_rows;
        m_cols = other.m_cols;
        m_data = new T[other.m_rows * other.m_cols];
        memcpy(m_data, other.m_data, sizeof(T) * m_rows * m_cols);
    }
    return *this;
}

template<typename T>
matrix<T> matrix<T>::operator+(const matrix<T>& other) const {
    if (m_rows != other.m_rows || m_cols != other.m_cols) {
        throw "Matrices must have the same dimensions.";
    }
    matrix<T> res(m_rows, m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < m_cols; j++) {
            res(i, j) = (*this)(i, j) + other(i, j);
        }
    }
    return res;
}

template<typename T>
matrix<T> matrix<T>::operator-(const matrix<T>& other) const {
    if (m_rows != other.m_rows || m_cols != other.m_cols) {
        throw "Matrices must have the same dimensions.";
    }
    matrix<T> res(m_rows, m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < m_cols; j++) {
            res(i, j) = (*this)(i, j) - other(i, j);
        }
    }
    return res;
}

template<typename T>
matrix<T> matrix<T>::operator*(const matrix<T>& other) const {
    if (m_cols != other.m_rows) {
        throw "Number of columns in first matrix must match number of rows in second matrix.";
    }
    matrix<T> res(m_rows, other.m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < other.m_cols; j++) {
            T sum = 0;
            for (int k = 0; k < m_cols; k++) {
                sum += (*this)(i, k) * other(k, j);
            }
            res(i, j) = sum;
        }
    }
    return res;
}

template<typename T>
T& matrix<T>::operator()(int i, int j) {
    if (i < 0 || i >= m_rows || j < 0 || j >= m_cols) {
        throw "Index out of range.";
    }
    return m_data[i * m_cols + j];
}

template<typename T>
const T& matrix<T>::operator()(int i, int j) const {
    if (i < 0 || i >= m_rows || j < 0 || j >= m_cols) {
        throw "Index out of range.";
    }
    return m_data[i * m_cols + j];
}

template<typename T>
int matrix<T>::rows() const {
    return m_rows;
}

template<typename T>
int matrix<T>::cols() const {
    return m_cols;
}

该矩阵类模板支持以下操作：

- 构造函数 `matrix(int a, int b)`：创建一个行数为 `a`，列数为 `b` 的矩阵，所有元素的初值为默认值（例如，0）。
- 拷贝构造函数 `matrix(const matrix<T>& other)`：创建一个与 `other` 完全相同的矩阵。
- 析构函数 `~matrix()`：释放矩阵占用的内存。
- 赋值运算符 `matrix<T>& operator=(const matrix<T>& other)`：将本矩阵赋值为 `other`。
- 加法运算符 `matrix<T> operator+(const matrix<T>& other) const`：返回本矩阵与 `other` 相加的结果。要求本矩阵与 `other` 的行列数相同。
- 减法运算符 `matrix<T> operator-(const matrix<T>& other) const`：返回本矩阵与 `other` 相减的结果。要求本矩阵与 `other` 的行列数相同。
- 乘法运算符 `matrix<T> operator*(const matrix<T>& other) const`：返回本矩阵与 `other` 相乘的结果。要求本矩阵的列数等于 `other` 的行数。
- 括号运算符 `T& operator()(int i, int j)` 和 `const T& operator()(int i, int j) const`：分别用于访问矩阵中第 `i` 行、第 `j` 列的元素。若下标越界，则抛出异常。
- `int rows() const` 和 `int cols() const`：分别返回矩阵的行数和列数。

使用时，需要先定义一个矩阵类模板实例，例如：

matrix<int> m1(2, 3);
matrix<int> m2(3, 2);

然后就可以使用矩阵类模板中定义的各种运算符进行矩阵计算。例如：

matrix<int> m3 = m1 + m2;
matrix<int> m4 = m1 - m2;
matrix<int> m5 = m1 * m2;