C++作业:向量类和矩阵类的操作符重载

最新推荐文章于 2021-10-15 08:29:12 发布
最新推荐文章于 2021-10-15 08:29:12 发布
阅读量1k 收藏 9
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46292082/article/details/111066670
版权

文章目录

向量类和矩阵类的操作符重载

题目要求

题目描述
实现一个向量类，一个矩阵类。在这两个类中，分别重载 “+， -， *(数乘，矩阵乘) ” 基本运算以及 “==，!=，-(负号)， =(赋值)" 操作符，以实现向量、矩阵的基本运算。
要求：

  1. 除了重载相应的操作符，也需要实现一个类的一些基本的方法(接口），比如构造、析构、拷贝构造等。
  2. 可以使用C++标准模板库(STL)里面的vector类，也可以使用你前一次作业实现的动态数组作为你这次所要实现的向量类的基础。

提示：

  • 此次会提供一份测试代码（非线上测试代码）
  • 该测试用例中涉及的Vecto自行设计，逐渐熟悉并掌握类接口设计能力
  • 建议可以先注释掉全部或大部分测试代码，从而以免在一开始因代码仅完成很少部分，产生太多编译错误
  • 仅通过测试代码分析类的职责，开发完成后，放开测试代码
  • 测试不通过，再考虑职责分析是否有误解
  • 建议思考的方式为“我应该为Vector提供什么接口，这些接口应当完成什么功能以满足他们的职责”为出发点，实现后通过测试用例验证
  • 而非“我应该为Vector提供什么接口，以能通过测试代码”为出发点，通不过一句，改一个函数，通过一句，就转移到下一个函数的方式
  • 前者以对象为中心，考虑职责，在思考过程和实现过程中，类独立设计并实现，最终通过交互完成功能，类设计和实现的过程和测试代码的顺序无关，
  • 仅与自身从测试代码中分析并融合出的职责需求有关
  • 后者以过程为中心，考虑功能，思考过程和实现的过程中，类在不断的“测试过程”中运行，以测试代码运行的顺序增加功能

输入
注：由于这次作业不需要提交main()函数，因此输入部分不需要过多关注

第一行n为整数，表示操作的个数
第二行的是对数组进行相应操作的代码（整数编码）序列，以空格分隔。

第三行是m 个数据（m操作序列所需的操作数决定）。

注：由于这次作业不需要提交main()函数，因此输入部分不需要过多关注
在这里插入图片描述

思考过程

  • 向量类使用了vector容器
  • 矩阵类使用线性的内存,顺序存放
  • assert()的调用使得调试更加方便

代码

/*向量类和矩阵类的重载运算
* by——keli
*2020.12.12
*/
#include<stdio.h>
#include<assert.h>
#include<iostream>
#include<vector>
#include<string.h>
using namespace std;
class Vector
{
public:
    //typedef std::vector<double> Data;
    static Vector INVALID_VECTOR;

public:
    //无参数构造函数
    Vector();

    //长度和一个数组为参数的构造函数
    Vector(int length, const double data[]);

    //参数为长度和一个double数的构造函数
    Vector(int length, const double data);

    //析构函数
    ~Vector();   
public:
    //返回向量元素个数
    int size() const;

    //重载[]
    double operator[](int index) const;

    //重载＋
    Vector operator+(const Vector& temp) const;

    //重载-
    Vector operator-(const Vector& temp) const;
    
    //重载*
    Vector operator*(const double a) const;

    //重载==
    bool operator==(const Vector& temp) const;

    //重载!=
    bool operator!=(const Vector& temp) const;

    //重载负号
    Vector operator-() const;

    //重载=double
    Vector operator=(const double element);

    //重载+double，每个元素都加一个数
    Vector operator+(const double element)const;

    //重载-double，每个元素都减一个数
    Vector operator-(const double element);
private:
    //重载<<
    friend std::ostream& operator<<(std::ostream& os, const Vector& vector);
private:
    //数据,向量p
    vector<double>p;
};
Vector::Vector()
{
    p.clear();
}
Vector::Vector(int length, const double data[])
{
    //这里的初始化和容器插入不同，必须先把容器归零
    p.clear();
    for (int i = 0; i < length; i++)
    {//把data[]的数据放入vector
        p.push_back(data[i]);
    }
}
Vector::Vector(int length, const double data)
{
    p.clear();
    for (int i = 0; i < length; i++)
    {
        p.push_back(data);
    }//length个数据初始为data
}
Vector::~Vector()
{
    p.clear();//清理内存
}
int Vector::size()const
{
    //vector内置函数size，返回容器元素个数
    return p.size();
}
double Vector::operator[](int index)const
{
    //随机访问容器元素
    return p.at(index);
}
Vector Vector::operator+(const Vector& temp)const
{
    if (p.size() != temp.p.size())//容量不相等时
    {
        return Vector::INVALID_VECTOR;//返回非法向量
    }
    Vector sum;//和向量
    for (int i = 0; i < p.size(); i++)
    {
        sum.p.push_back(p.at(i) + temp.p.at(i));
    }
    return sum;
}
Vector Vector::operator-(const Vector& temp)const
{
    if (p.size() != temp.p.size())//容量不相等时
    {
        return Vector::INVALID_VECTOR;//返回非法向量
    }
    Vector difference;//差向量
    for (int i = 0; i < p.size(); i++)
    {
        difference.p.push_back(p.at(i) - temp.p.at(i));
    }
    return difference;    
}
Vector Vector::operator*(const double a)const
{
    Vector product;//积向量
    for (int i = 0; i < p.size(); i++)
    {
        product.p.push_back(p.at(i)*a);
    }
    return product;
}
bool Vector::operator==(const Vector& temp)const
{
    return (this->p == temp.p);
}
bool Vector::operator!=(const Vector& temp)const
{
    return (!(this->p == temp.p));
}
Vector Vector::operator-()const
{
    Vector opposite;
    for (int i = 0; i < p.size(); i++)
    {
        opposite.p.push_back(p.at(i)*(-1.0));
    }
    return opposite;
}
Vector Vector::operator=(const double element)
{//把值改为3，长度不变
    int _len = p.size();
    p.clear();//容器重置
    p.resize(_len, element);
    return *this;
}
Vector Vector::operator+(const double element)const
{
    Vector dst;
    for (int i = 0; i < p.size(); i++)
    {
        dst.p.push_back(p[i] + element);
    }
    return dst;
}
Vector Vector::operator-(const double element)
{
    Vector dst;
    for (vector<double>::iterator it = p.begin(); it < p.end(); ++it)
    {
        dst.p.push_back(*it - element);
    }
    return dst;
}

std::ostream& operator<<(std::ostream& os, const Vector& vector)
{
    for (int i = 0; i < vector.p.size(); i++)
        os << vector.p.at(i) << " ";
    os << std::endl;
    return os;
}

//把无效向量设置为0向量
Vector Vector::INVALID_VECTOR(0, 1.0);

/****************下面是矩阵类******************************************/
class Matrix
{
public:
    /// 定义类型便于其他代码使用
    // typedef std::vector<Vector> Data;
    /// 定义非法矩阵，这里用0 * 0矩阵表示，也可在Matrix中添加一个特殊标志位
    static Matrix INVALID_MATRIX;

public:
    // Matrix类构造函数.
    /// 默认构造函数要加，否则vector无法resize
    Matrix();

    //用向量初始化矩阵的构造函数
    Matrix(const Vector& rsh);

    //初始化行、列的构造函数
    Matrix(int row, int col);

    //行列向量，三参数构造函数
    Matrix(int row, int col, const double data[]);

    //行列和一个双精度数的构造函数
    Matrix(int row, int col, const double data);

    //拷贝构造函数
    Matrix(const Matrix& rsh);

    // Matrix类析构函数
    ~Matrix()
    {
        delete[] p;
        row = 0;
        column = 0;
    }

    //返回行数
    int rows()const;

    //返回列数
    int cols()const;
    
    //矩阵转置
    Matrix trans()const;
public:
    //重载矩阵的数乘
    Matrix operator*(const double element)const;

    //重载[],返回值是指针，本质上为了实现matrix[][]的访问  
    double* operator[](const int row)const;
    
    //重载==
    bool operator==(const Matrix& rsh)const;

    //重载!=
    bool operator!=(const Matrix& rsh)const;

    //重载+
    Matrix operator+(const Matrix& rsh)const;

    //重载-
    Matrix operator-(const Matrix& rsh)const;

    //重载相反数运算
    Matrix operator-(void)const;

    //重载矩阵乘法
    Matrix operator*(const Matrix& rsh)const;

    
private:  
    // Matrix类私有实现方法
    int row; // 行
    int column;//列
    
    //访问时p[i+j*column]就相当于二维数组里的p[i][j]
    double * p;//一维向量来存储矩阵
private:
    /// 所有成员变量应设为私有

    /// operator<<需加友元声明，否则无法打印
    friend std::ostream& operator<<(std::ostream& out, const Matrix& rsh);
}; // class Matrix类定义结束.
Matrix::Matrix()
{
    p = NULL;
    row = 0;
    column = 0;
}
Matrix::Matrix(const Vector& rsh)
{//向量相当于行数为1的矩阵
    row = 1;
    column = rsh.size();
    p = new double[row*column];
    for (int j = 0; j < row * column; j++)
    {
        p[j] = rsh[j];
    } 
}
Matrix::Matrix(int row, int col)
{
    this->row = row;
    this->column = col;
    p=new double[row * column];
}
Matrix::Matrix(int row, int col, const double data[])
{
    this->row = row;
    this->column = col;
    p = new double[row * column];
    for (int i = 0; i < row*column; i++)
    {
        p[i] = data[i];
    }
}
Matrix::Matrix(int row, int col, const double data)
{
    this->row = row;
    this->column = col;
    p = new double[row * column];
    for (int i = 0; i < row * column; i++)
    {
        p[i] = data;
    }
}
Matrix::Matrix(const Matrix& rsh)
{
    row = rsh.row;
    column = rsh.column;
    p = new double[row * column];
    for (int i = 0; i < row * column; i++)
    {
        p[i] = rsh.p[i];
    }
}
int Matrix::rows()const
{
    return row;
}
int Matrix::cols()const
{
    return column;
}
Matrix Matrix::operator*(const double element) const
{
    Matrix dst(*this);
    for (int i = 0; i < row * column; i++)
        dst.p[i] = p[i] * element;
    return dst;
}
double* Matrix::operator[](const int row)const
{
    return p + row * this->column;
}
bool Matrix::operator==(const Matrix& rsh) const
{
    if (row != rsh.row || column != rsh.column)
        return false;
    for (int i = 0; i < row * column; i++)
    {
        if (rsh.p[i] != p[i])
            return false;
    }
    return true;
}
bool Matrix::operator!=(const Matrix& rsh) const
{
    return !(*this == rsh);
}
Matrix Matrix::operator+(const Matrix& rsh) const
{
    //矩阵行数列数不一样时返回非法矩阵
    if (row != rsh.rows() || column != rsh.cols())
        return INVALID_MATRIX;
    Matrix dst(*this);
    for (int i = 0; i < dst.cols() * dst.rows(); i++)
    {
        dst.p[i] = p[i] + rsh.p[i];
    }
    return dst;
}
Matrix Matrix::operator-(const Matrix& rsh) const
{
    //矩阵行数列数不一样时返回非法矩阵
    if (row != rsh.rows() || column != rsh.cols())
        return INVALID_MATRIX;
    Matrix dst(*this);
    for (int i = 0; i < dst.cols() * dst.rows(); i++)
    {
        dst.p[i] = p[i] - rsh.p[i];
    }
    return dst;
}
Matrix Matrix::operator-(void)const
{
    Matrix dst(*this);
    for (int i = 0; i < dst.cols() * dst.rows(); i++)
    {
        dst.p[i] = -p[i];
    }
    return dst;
}
Matrix Matrix::operator*(const Matrix& rsh)const
{
    if (this->cols() != rsh.rows())//第一个矩阵的列数与第二个矩阵的行数不相等
    {//返回非法矩阵
        return Matrix::INVALID_MATRIX;
    }
    Matrix dst(this->rows(), rsh.cols());
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < dst.column; j++)
        {
            double temp = 0;
            for (int k = 0; k <column; k++)
            {
                temp += (*this)[i][k] * rsh[k][j];
            }
            dst[i][j]= temp;
        }
    }
    return dst;
}
Matrix Matrix::trans()const
{
    Matrix dst(this->cols(), this->rows());
    for (int i = 0; i <rows(); i++)
    {
        for (int j = 0; j <cols(); j++)
        {
            dst[j][i] = (*this)[i][j];
        }
    }
    return dst;
   
}



//非法矩阵设置为0
Matrix Matrix::INVALID_MATRIX(0, 0);
// 定义Matrix流输出操作
std::ostream& operator<<(std::ostream& out, const Matrix& rsh)
{
    out << "输出矩阵" << endl;
    for (int i = 0; i < rsh.row; i++)
    {
        for (int j = 0; j < rsh.column; j++)
        {
            out << rsh.p[j + i * rsh.column] << " ";
        }
        out << endl;
    }
    return out;
}





// 提供的测试代码
// 该测试用例中涉及的Vector及Matrix自行设计，逐渐熟悉并掌握类接口设计能力
// 建议可以先注释掉全部或大部分测试代码，从而以免在一开始因代码仅完成很少部分，产生太多编译错误
// 仅通过测试代码分析类的职责，开发完成后，放开测试代码
// 测试不通过，在考虑职责分析是否有误解
// 建议思考的方式为“我应该为Vector和Matrix提供什么接口，这些接口应当完成什么功能以满足他们的职责”为出发点，实现后通过测试用例验证
// 而非“我应该为Vector和Matrix提供什么接口，以能通过测试代码”为出发点，通不过一句，改一个函数，通过一句，就转移到下一个函数的方式
// 前者以对象为中心，考虑职责，在思考过程和实现过程中，类独立设计并实现，最终通过交互完成功能，类设计和实现的过程和测试代码的顺序无关，
// 仅与自身从测试代码中分析并融合出的职责需求有关
// 后者以过程为中心，考虑功能，思考过程和实现的过程中，类在不断的“测试过程”中运行，以测试代码运行的顺序增加功能

int main(int argc, char *argv[])
{
    // 通过传递元素素组初始化向量，最终将得到3个元素
    double data1[] = {3.4, 4.4, 6.0};
    Vector v(sizeof(data1) / sizeof(double), data1);  
    // 确保完备的初始化向量
    assert(v.size() == sizeof(data1) / sizeof(double));    
    for (int idx = 0; idx < sizeof(data1) / sizeof(double); ++idx)
    {
        assert(v[idx] == data1[idx]);
    }    
    // v的值应等于自身，且不会不等于自身
    assert(v == v);
    assert(!(v != v));    
    // v + v按元素分别求和的结果，相当于每个元素直接与2相乘
    assert(v + v == v * 2);    
    // v - v按元素分别求和的结果，相当于v加上v的相反数
    assert(v - v == v + (-v));    
    // v = 3的结果使向量的每个元素都变为3，因此等于直接初始化一个只有三个元素，且初始值为3的向量
    assert((v = 3) == Vector(sizeof(data1) / sizeof(double), 3));    
    // v + 3的结果使向量的每个元素都加上3，因此等于直接初始化一个只有三个元素，且初始值为6的向量
    // 而 v - 3则直接初始化一个只有三个元素，且初始值为0的向量
    assert(v + 3 == Vector(sizeof(data1) / sizeof(double), 6));
    assert(v - 3 == Vector(sizeof(data1) / sizeof(double), 0.0));  
    // 另行定义一个有十个元素，且每个元素值为5的向量
    Vector v2(10, 5);
    // 确保其正确初始化
    assert(v2.size() == 10);
    for (int idx = 0; idx < v2.size(); ++idx)
    {
        assert(v2[idx] == 5);
    }    
    // 两个元素个数不相等的向量相加，其结果为【无效向量】
    assert(v + v2 == Vector::INVALID_VECTOR);
     
    //
    // 通过传递元素素组初始化矩阵，3( 行) X 2(列) 矩阵为：
    // 1 1
    // 1 1
    // 1 1
    double data2[] = {1, 1, 1, 1, 1, 1};  
    Matrix m1(3, 2, data2);
  
   
    // m4等于m1乘以标量2，因此按元素分别求乘积，得到3( 行) X 2(列) 矩阵，为：
    // 2 2
    // 2 2
    // 2 2
    Matrix m4 = m1 * 2;
    
    // 确保m1初始化正确，且与标量乘积正确
    assert(m4.rows() == 3);
    assert(m4.cols() == 2);
    for (int r = 0; r < 2; ++r)
    {
        for (int c = 0; c < 2; ++c)
        {
            assert(m4[r][c] == 2);
        }
    }
    
    // 以同样的数组初始化矩阵，但如果行数、列数不同，获得的矩阵也不同
    Matrix m2(6, 1, data2);
    Matrix m3(3, 2, data2);
   
    // 因此m1与m2同样有6个1，但行列不同，因此不相等
    assert(m1 != m2);
    // 只有m3这样的行列相同，元素相同，才应相等
    assert(m1 == m3);

    // 同样的结果可以通过直接初始化每个元素为一个相同的数值得到
    assert(m1 == Matrix(3, 2, 1));
   
    // m1相加之后，应得到一个3行2列，元素全为2的矩阵
    assert(m1 + m1 == Matrix(3, 2, 2));
    // 但如果矩阵行列不同，无法直接相加，只能得到非法矩阵
    assert(m1 + m2 == Matrix::INVALID_MATRIX);

    // 同样，减法按元素相减，相当于加上相反数
    assert(m1 - m1 == m1 + (-m1));
    // 相反数的结果应正确
    assert(-m1 == Matrix(3, 2, -1));
    
    // 在乘法中，如果矩阵行列不满足条件，只能得到非法矩阵
    assert(m1 * m1 == Matrix::INVALID_MATRIX);
    // 满足乘法条件，m1与其转置矩阵的乘积((3 X 2) X (2 X 3))为3行3列元素为2矩阵
    assert(m1 * m1.trans() == Matrix(3, 3, 2));
    // 满足乘法条件，m1转置矩阵与m1的乘积((2 X 3) X (3 X 2))为2行2列元素为3矩阵
    assert(m1.trans() * m1 == Matrix(2, 2, 3));
    //cout << v;
    cout << m1;
    cout << Matrix(v);
    cout << (Matrix(v) * m1);
    //向量可转化为矩阵与矩阵相乘，同样要满足矩阵乘法条件，由于v相当于1X3矩阵，元素为3，因此结果为1X2矩阵，元素为9
    assert(Matrix(v) * m1 == Matrix(1, 2, 9));
    // 改变顺序后也可通过转置获得另一个乘积，因此结果为2X1矩阵，元素为9，即相当于上面一个结果的转置
    assert(m1.trans() * Matrix(v).trans() == Matrix(2, 1, 9));
    
    return 0;
}

结果展示

  • 本次实验实际上没有输入和输出
  • 为了展示结果,写了一个show()函数,再最后进行调用
void show()
{
    // 通过传递元素素组初始化向量，最终将得到3个元素
    double data1[] = { 3.4, 4.4, 6.0 };
    Vector v(sizeof(data1) / sizeof(double), data1);
    cout << "v";
    cout << v;
    // 另行定义一个有十个元素，且每个元素值为5的向量
    Vector v2(10, 5);
    cout << "v2";
    cout << v2;
    double data2[] = { 1, 1, 1, 1, 1, 1 };
    Matrix m1(3, 2, data2);
    Matrix m4 = m1 * 2;
    Matrix m2(6, 1, data2);
    Matrix m3(3, 2, data2);
    cout << "m1"  << m1;
    cout << "m2" << m2;
    cout << "m3"  << m3;
    cout << "m4"  << m4;
    cout << "m1转置" << m1.trans();
    cout << "Matrix(v) * m1" << Matrix(v) * m1;
}

调用显示函数,结果为
在这里插入图片描述

总结

  • 再次复习了vector容器的基本用法
  • 复习了C++内存的申请和使用
  • 进一步掌握了程序调试方法,assert()函数的使用
xsa_deleteMemory
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第九周——运算符重载——项目四 向量类
舒绾
05-08 1018
问题及代码： /* *Copyright (c) 2014,烟台大学计算机学院 *All rights reserved. *文件名称:lily.cpp *作者:李莉 *完成日期:2015年5月5日 *版本号:v1.0 * *问题描述：实现向量类中的运算符重载, *程序输入：无输入 *程序输出：如结果图 */ #include using
C++矩阵类&操作符重载
jiyuanyi1992的专栏
04-10 3066
一年前刚刚告别了数值计算的学习，也就注定了我此生与矩阵计算越走越远，说来还有些伤感——今天帮助小学弟（妹）写c++，大致是类入门的一些东西。
重载向量运算
lannister_awalys_pay的博客
09-24 723
   
C++实现矩阵类和向量类
康宇的博客
05-28 6063
C++期末作业内容，写完之后觉得过于臃肿，又重新搞了个新的。新的当作业交，旧的拿来给同学参考。 【问题描述】请仿照复数类，设计一个矩阵类，设计矩阵类的构成元素 1.编写构造函数完成初始化 2.编写成员函数，读入一个矩阵，输出一个矩阵 3.编写成员函数，计算两个矩阵相加、相减、点乘 4.编写成员函数，利用运算符重载计算两个矩阵的相加、相乘、点乘、输出，并输出计算结果 例如输入3 3，表示是一个3*3...
向量重载(纯脚本)
weixin_36277593的博客
09-22 199
struct Vector : IFormattable    {       public double x, y, z;       public Vector(double x, double y, double z)       {          this.x = x;          this.y = y;          this.z = z;      
C++实现向量类和矩形类
qq_46600553的博客
01-02 1269
用C++实现向量类和矩形类 任务：实现一个向量类，一个矩阵类。在这两个类中，分别重载 “+， -， *(数乘，矩阵乘) ” 基本运算以及 “==，!=，-(负号)， =(赋值)" 操作符，以实现向量、矩阵的基本运算。 #include <iostream> #include <vector> #include <assert.h> class Vector { public: typedef std::vector<double> Data;
C++入门学习笔记(三)--类的操作符重载
happyforever_Wang的专栏
12-24 498
1、操作符 在C++中，除了四种操作符外(“::”,” .*”,”.”,” ?:”)，其它内置的操作符大部分都可以是重载，但不能创造其它新的运行符如 “**”。 在类类型中，操作符重载即可以是类成员操作符也可是非类成员操作符，如果一个操作符不属于该类成员，那一般是以友元的形式出现。 操作符重载的一般格式如下： [返回类型] operator([形参列表]) {
Opencv Mat类的操作符重载及矩阵操作
u010363630的专栏
04-09 4765
Opencv的Mat类越来越接近于Matlab中矩阵操作了。这里简单的总结一下：   四则运算： +，-：没什么可说的，矩阵相加或者矩阵+数字。与add和divide函数是近似的 *，/：有一些可说的，直接A*B实际上时矩阵的运算，而不是对应值的相乘，想完成对应值的相乘可A.mul(B);            对于除法，C = A / B 的操作过程中，如果B(i,j)=0，则C(i,
C++矩阵类的实现
03-13
矩阵的加减乘除操作可以通过重载操作符`+`、`-`、`*`和`/`来实现。这些操作通常涉及到两个`Matrix`对象，因此需要定义相应的成员函数。对于乘法操作，需要注意的是，当一个矩阵乘以另一个矩阵时，必须满足第二个矩阵...
实现操作符重载 实现操作符重载
12-30
操作符重载是C++提高代码可读性和易用性的重要手段。正确、合理地重载操作符可以使类的行为更符合用户的直觉，提高代码的优雅度。但在设计和实现时，需要注意重载的合理性和效率，避免引入不必要的复杂性。理解并...
c++实现矩阵类
10-07
简单的c++代码实现矩阵类的学习要求，仅供初学者参考，
一个老外写的可扩展C++矩阵类（包括实例，VS2010可用）
07-23
一个老外写的可扩展C++矩阵类（包括实例，VS2010可用）
cpp代码-重载操作符operator
07-14
在C++编程语言中，重载操作符是提高代码可读性和灵活性的一种重要特性。它允许程序员为已有的运算符赋予新的含义，以便在自定义数据类型上使用。...理解并正确使用操作符重载，能极大地提升C++编程的效率和质量。
Matrix矩阵类
10-26
4. 操作符重载：描述中提到的“重载+，-，*，/运算符”，这是C++中的特性，使得我们可以像操作普通数值一样操作矩阵。例如，"+"代表矩阵相加，"-"可以表示减法或取负，"*"表示矩阵乘法（注意，这不是元素级乘法，...
c++实现矩阵类(使用 vector)
beyondzty的博客
10-15 1506
class Matrix//矩阵类 { public: vector<vector<double>>data; int rows;//行数 int columns;//列数 Matrix(int rowNum,int columnNum)//初始化构造函数 { rows = rowNum; columns = columnNum; data.resize(rows); for (int i = 0; i < rows; i++) { da..
用c++设计一个矩阵类，要求在矩阵类中重载“+”、“-”、“*”、“=”运算符。
小治成长记
11-29 3075
#include<iostream> using namespace std; class Rectangle { public: Rectangle(double y=0):x(y){} Rectangle operator+(Rectangle& a); Rectangle operator-(Rectangle& b); Rectangle operator*(Rectangle& c); Rectangle operator=(Rectangle d);
C++11运算符重载和向量类重载实例详解（＜＜,＞＞,+,-,*等）
D64juaz的博客
07-15 769
这篇文章主要给大家介绍了关于C++11运算符重载和向量类重载的相关资料，主要包括＜＜,＞＞,+,-,*等,文中通过示例代码介绍的非常详细,需要的朋友可以参考下 目录 1. C++运算符重载介绍 1.1 单目运算符与双目运算符 1.2 友元运算符 2. 实例讲解 2.1 头文件定义 2.2 实现运算符重载 总结 1. C++运算符重载介绍 C ++ 中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须
C++矩阵和向量之间的操作
小凡的专栏
04-17 3455
进行数据分析时，常需要显示矩阵和向量，以及取出矩阵的某一行或者某一列并将它存成向量，或将向量存到矩阵的某一列或某一行。以下程序展示了这类操作： #include "stdafx.h" #include #include #include using namespace std; const int M = 4; const int N = 5; void ShowMatrix(doubl
线性代数学习
weixin_34223655的博客
11-08 213
向量：一组数的基本表示方法 和向量相对应，一个数字，成为标量 向量是线性代数研究的基本元素 import math from ._global import EPSILON class Vector: def __init__(self, lst): self._values = list(lst) # 相当于复制了一次lst，使得这个类更符合不可更改类型 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值