一个用来翻转、旋转的矩阵类

最新推荐文章于 2022-06-29 11:16:57 发布

原创最新推荐文章于 2022-06-29 11:16:57 发布 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#delete #class

常用代码专栏收录该内容

10 篇文章

订阅专栏

博客展示了一个模板类LMatrix的实现，包含构造、析构函数，以及取值、设置值等基本操作。还实现了左转、右转、向下旋转、水平和垂直翻转等矩阵操作，通过动态内存分配和释放管理矩阵数据。

template<typename T>
class LMatrix
{
    int m_x;
    int m_y;
    T *m_data;
public:
    // 构造函数，横坐标范围0～(x - 1)，纵坐标范围0～(y - 1)
    LMatrix(int x, int y) : m_x(x), m_y(y), m_data(new T[x * y]) {}
    // 析构函数
    ~LMatrix()
    {
        delete[] m_data;
    }
    // 取值
    T GetAt(int x, int y)
    {
        return m_data[y * m_x + x];
    }
    // 设置值
    void SetAt(int x, int y, T value)
    {
        m_data[y * m_x + x] = value;
    }
    // 左转90度
    void RolLeft()
    {
        T *p = new T[m_x * m_y];
        int i, j, t;
        for (j = 0; j < m_x; j++)
        {
            for (i = 0; i < m_y; i++)
            {
                p[j * m_y + i] = m_data[i * m_x + m_y - j];
            }
        }
        t = m_x;
        m_x = m_y;
        m_y = t;
        delete[] m_data;
        m_data = p;
    }
    // 右转90度
    void RolRight()
    {
        T *p = new T[m_x * m_y];
        int i, j, t;
        for (j = 0; j < m_x; j++)
        {
            for (i = 0; i < m_y; i++)
            {
                p[j * m_y + i] = m_data[(m_y - i - 1) * m_x + j];
            }
        }
        t = m_x;
        m_x = m_y;
        m_y = t;
        delete[] m_data;
        m_data = p;
    }
    // 向下旋转
    void RolDown()
    {
        int i, t;
        int n = m_x * m_y;
        int m = n / 2;
        for (i = 0; i < m; i++)
        {
            t = m_data[i];
            m_data[i] = m_data[n - i - 1];
            m_data[n - i - 1] = t;
        }
    }
    // 水平翻转
    void HorTurn()
    {
        int i, j, t;
        int n = m_x / 2;
        for (j = 0; j < m_y; j++)
        {
            for (i = 0; i < n; i++)
            {
                t = m_data[j * m_x + i];
                m_data[j * m_x + i] = m_data[(j + 1) * m_x - i - 1];
                m_data[(j + 1) * m_x - i - 1] = t;
            }
        }
    }
    // 垂直翻转
    void VerTurn()
    {
        int i, j, t;
        int n = m_y / 2;
        for (i = 0; i < m_x; i++)
        {
            for (j = 0; j < n; j++)
            {
                t = m_data[j * m_x + i];
                m_data[j * m_x + i] = m_data[(m_y - j - 1) * m_x + i];
                m_data[(m_y - j - 1) * m_x + i] = t;
            }
        }
    }
};