数据结构之 矩阵 模板类

最新推荐文章于 2023-06-16 01:05:09 发布
原创 最新推荐文章于 2023-06-16 01:05:09 发布 · 735 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++ #矩阵

28日更新：我按照之前的约定，写完啦！

先预约一片在这里，最近两天把他写完（其实已经写完了，只是还没有誊写到个人笔记本上）

#include<iostream>
#ifndef _H_MYMATRIX_H
#define _H_MYMATRIX_H

template<class T>
class myMatrix;

template<class T>
std::ostream& operator<<(std::ostream& out, const myMatrix<T>& otherMatrix);

template<class T>
void swap(T& val1, T& val2);

template<class T>
class myMatrix
{
public:
    myMatrix(const int row = 1, const int col = 1);
    myMatrix(const myMatrix<T>& otherMatrix);
    ~myMatrix();

    int rows(void) const {return m_row;}
    int cols(void) const {return m_col;}

     myMatrix<T>& operator=(const myMatrix<T>& otherMatrix);
     myMatrix<T> operator+(const myMatrix<T>& otherMatrix);
     myMatrix<T> operator+(const T val);
     myMatrix<T> operator-(const myMatrix<T>& otherMatrix);
     myMatrix<T> operator-(T val);
     myMatrix<T> operator*(const myMatrix<T>& otherMatrix);
     myMatrix<T> operator*(T val);
     T& operator()(const int row, const int col);

     void transpose(void);

    void output(std::ostream& out);
private:
    int m_col;
    int m_row;
    T* m_ptr;
};

#endif

template<class T>
myMatrix<T>::myMatrix(const int row = 1, const int col = 1)
{
    if(col <= 0 || row <= 0)
    {
        return;
    }
    m_row = row;
    m_col = col;
    m_ptr = new T[row * col];
    memset(this->m_ptr, 0, row * col * sizeof(T));///2017 11 02晚上增加*sizeof(T),这很重要
}

template<class T>
myMatrix<T>::myMatrix(const myMatrix<T>& otherMatrix)
{
    m_row = otherMatrix.rows();
    m_col = otherMatrix.cols();
    m_ptr = new T[m_col * m_row];
    memcpy(m_ptr, otherMatrix.m_ptr, m_col * m_row * sizeof(T));
}

template<class T>
myMatrix<T>::~myMatrix()
{
    delete[] (this->m_ptr);
}

template<class T>
myMatrix<T>& myMatrix<T>::operator=(const myMatrix<T>& otherMatrix)
{
    if(&otherMatrix != this)
    {
        delete[] (this->m_ptr);
        m_row = otherMatrix.rows();
        m_col = otherMatrix.cols();
        m_ptr = new T[m_col * m_row];
        memcpy(m_ptr, otherMatrix.m_ptr, m_col * m_row * sizeof(T));
    }
    return (*this);
}

template<class T>
myMatrix<T> myMatrix<T>::operator+(const myMatrix<T>& otherMatrix)
{
    if (m_col != otherMatrix.cols() || m_row != otherMatrix.rows())
    {
        throw("DimensionNotMatched");
    }
    myMatrix<T> mat(m_row, m_col);
    for(int ii = 0; ii < m_col * m_row; ii++)
    {
        mat.m_ptr[ii] = this->m_ptr[ii] + otherMatrix.m_ptr[ii];
    }
    return mat;
}

template<class T>
myMatrix<T> myMatrix<T>::operator+(const T val)
{
    myMatrix<T> mat(m_row, m_col);
    for(int ii = 0; ii < m_col * m_row; ii++)
    {
        mat.m_ptr[ii] = this->m_ptr[ii] + val;
    }
    return mat;
}

template<class T>
myMatrix<T> myMatrix<T>::operator-(const myMatrix<T>& otherMatrix)
{
    if (m_col != otherMatrix.cols() || m_row != otherMatrix.rows())
    {
        return;
    }
    myMatrix<T> mat(m_row, m_col);
    for(int ii = 0; ii < m_col * m_row; ii++)
    {
        mat.m_ptr[ii] = this->m_ptr[ii] - otherMatrix.m_ptr[ii];
    }
    return mat;
}

template<class T>
myMatrix<T> myMatrix<T>::operator-(T val)
{
    myMatrix<T> mat(m_row, m_col);
    for(int ii = 0; ii < m_col * m_row; ii++)
    {
        mat.m_ptr[ii] = this->m_ptr[ii] - val;
    }
    return mat;
}

template<class T>
myMatrix<T> myMatrix<T>::operator*(const myMatrix<T>& otherMatrix)
{
    if(this->m_col == otherMatrix.rows())
    {
        myMatrix<T> mat(this->m_row, otherMatrix.cols());
        for(int ii = 0; ii < this->m_row; ii++)
        {
            for(int jj = 0; jj < otherMatrix.cols(); jj++)
            {
                mat.m_ptr[ii * otherMatrix.cols() + jj] = 0;
                for(int kk = 0; kk < this->m_col; kk++)
                {
                    mat.m_ptr[ii * otherMatrix.cols() + jj] = mat.m_ptr[ii * otherMatrix.cols() + jj] + 
                        this->m_ptr[ii * this->m_col + kk] * otherMatrix.m_ptr[kk * otherMatrix.cols() + jj];
                }
            }
        }
        return mat;
    }
    else
    {
        throw("DimensionNotMatched");
    }
}

template<class T>
myMatrix<T> myMatrix<T>::operator*(T val)
{
    myMatrix<T> mat(m_row, m_col);
    if(0 == val)
    {
        memset(mat.m_ptr, 0, m_col * m_row);
    }
    else
    {
        for(int ii = 0; ii < m_col * m_row; ii++)
        {
            mat.m_ptr[ii] = this->m_ptr[ii] * val;
        }
    }
    return mat;
}

template<class T>
T& myMatrix<T>::operator()(const int row, const int col)
{
    if(row > 0 && row <= m_row && col <= m_col && col > 0 )
    {
        return (this->m_ptr[(row - 1) * m_col + col - 1]);
    }///2017 11 02增加下面else部分
    else
    {
        throw("WrongIndex");
    }
}

template<class T>
void myMatrix<T>::transpose(void)
{
    ////思路：通过重新申请一块内存来，将原来的元素按照转置之后的顺序排列
    T* ptr = new T[this->m_col * this->m_row];
    for(int ii = 0;ii < this->m_row; ii++)
    {
        for(int jj = 0; jj < this->m_col; jj++)
        {
            ptr[jj * this->m_row + ii] = this->m_ptr[ii * this->m_col +jj];
        }
    }
    swap(this->m_col, this->m_row);
    delete[] (this->m_ptr);
    this->m_ptr = ptr;
}

template<class T>
void myMatrix<T>::output(std::ostream& out)
{
    out<<"地址为："<<this<<std::endl;
    for(int ii = 0; ii < m_row; ii++)
    {
        for(int jj = 0; jj < m_col; jj++)
        {
             out<<"\t"<<(this->m_ptr[ii * m_col + jj]);
        }
        out<<std::endl;
    }
}

template<class T>
void swap(T& val1, T& val2)
{
    val1 = val1 + val2;
    val2 = val1 - val2;
    val1 = val1 - val2;
}

template<class T>
std::ostream& operator<<(std::ostream& out, myMatrix<T>& otherMatrix)
{
    otherMatrix.output(out);
    return out;
}

还有很多的问题，还需要测试（28日测试完毕，好像没有什么问题了，请大家也帮忙测试一下）

#include <iostream>
#include "myMatrix.cpp"

void main(void)
{
    int row = 3;
    int col = 4;
    myMatrix<int> mat(row, col);

    for(int ii = 0; ii < row; ii++)
    {
        for(int jj = 0; jj < col; jj++)
        {
            mat(ii+1, jj+1) = ii + jj * jj;
        }
    }
    std::cout<<mat<<std::endl;  
    myMatrix<int> mat1 = mat;

    mat.transpose();
    std::cout<<mat<<std::endl;

    try
    {
        myMatrix<int> mat2 = mat * mat1;
        std::cout<<mat2<<std::endl;
    }
    catch(char* ex)
    {
        std::cout<<ex<<std::endl;
    }

    myMatrix<int> mat3;
    mat3 = mat + 6;
    std::cout<<mat3<<std::endl; 

    mat3 = mat + mat;
    std::cout<<mat3<<std::endl; 

    mat3 = mat * 6;
    std::cout<<mat3<<std::endl; 

    myMatrix<int> mat4(mat3);
    std::cout<<mat4<<std::endl; 

    std::system("pause");
}

///// 发现一个问题，模板类不太能够容忍return;的写法，如果函数的定义是要求返回值的，使用了这个不会编译通过，所以建议改成不符合的就throw异常

矩阵模板类
人生如路
01-09 1199
#include #include #include using namespace std; template class CMatrix { public: CMatrix(); CMatrix(int row, int col); CMatrix(int row, int col, T *data); CMatrix(CMatrix& m2);
矩阵类的模板
10-07
VC++中使用的矩阵类模板，实现了矩阵的存储，转置等问题。
类模板实现矩阵类
12-28
类模板实现矩阵类；能够输出矩阵的行数，列数和元素最大值等信息； c++；
C++课程设计矩阵模板类
12-19
用visual C++定义矩阵模板类，实现不同类型矩阵的计算，支持基本运算
【矩阵模板】
acquiesce
08-22 630
#include struct Mat { int N,M; int m[15][15]; }; Mat MatMul(Mat A,Mat B,int MOD) { //两个相等矩阵的乘法，对于稀疏矩阵，有0处不用运算的优化 Mat tmp; tmp.N=A.N; tmp.M=B.M; for(int i=0; i<A.N; i++) { for(int j=0; j<B.
数据结构（C++模板实现）-C++资源
最新发布
02-16
在这里，用户可以找到栈的模板类实现。 - Tree：树结构是数据结构中非常重要的一个分支，它模拟了自然界中的树结构，具有很好的层次性和分支性。在Tree文件夹中，可能包含了二叉树、红黑树、AVL树等不同类型的树...
C++ 数据结构之对称矩阵及稀疏矩阵的压缩存储
08-29
C++ 数据结构之对称矩阵及稀疏矩阵的压缩存储 对称矩阵和稀疏矩阵是数据结构中两个重要的概念，对称矩阵是指矩阵的转置矩阵等于它本身的矩阵，而稀疏矩阵是指矩阵中非零元素的个数远远小于总元素数的矩阵。压缩存储...
矩阵模版类
11-13
自己写的矩阵类，功能不完善，只有基本操作，解线性方程组
矩阵类模板
Black—Horse的专栏
01-17 1860
#include #include #include using namespace std; #define N 100 class Matrix { public: void Init(){ memset(data,0,sizeof(data));} void Matrix_multiply(const Matrix & A,const Matrix & B) { if (A.co
矩阵类模板（类模板）
Upward_3000的博客
06-16 564
在做学校OJ时遇到了一些问题，引发了一些思考，加深了对内存，动态指针数组，拷贝构造等知识的理解，便记了下来
C++ 矩阵类模板（类模板）
hhhertzzz的博客
06-18 5331
题目描述 设计一个矩阵类模板Matrix，支持任意数据类型的数据。 要求至少包含2个成员函数：矩阵转置函数transport、以及打印输出函数print 编写main函数进行测试，调用类的成员函数完成转置和输出。 输入 第一行先输入t，表示有t个测试用例 从第二行开始输入每个测试用例的数据。 首先输入数据类型，I表示int，D表示double，C表示char，接着输入两个参数m和n，分别表示矩阵的行和列 接下来输入矩阵的元素，一共m行，每行n个数据 输出 输出转置后的矩阵 样例输入 2 I 2 3 1 2.
数据结构模板
Confidence的专栏
08-06 1004
数据结构模板
数据结构-矩阵
sinat_41752325的博客
12-22 1958
导言 数据结构中，主要讨论如何在节省存储空间的情况下使矩阵的各种运算能高效地进行。 有些矩阵存在很多值相同的元素或者0元素，这时为了节省空间，就可以对这种矩阵进行压缩。压缩的原则是：为多个值相同的元素只分配一个存储单元，0元素不分配存储单元。 用于压缩的矩阵有特殊矩阵和稀疏矩阵 一、特殊矩阵 如果矩阵中的元素的分布有一定规律，称之为特殊矩阵。 常见的特殊矩阵有对称矩阵、三角矩阵、对角矩阵。 1.1 对称矩阵 若矩阵An*n中的元素特点是a[ij]=a[ji]，则称之为n阶对称矩阵。 对..
数据结构之矩阵
m0_62708923的博客
05-19 888
一、矩阵乘的计算 矩阵其实就是一个二维的表格，那么数据结构中的矩阵其实也是一样的，计算机中可以用矩阵这种形式来存储数据。 总代码： #include<stdio.h> #include<stdlib.h> #define TOTAL_SPACE 5 typedef struct CircleIntQueue { int data[TOTAL_SPACE]; int head; int tail; }*CircleIntQueuePtr; Circl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值