别出心栽地实现矩阵的运算（继承向量类）

最新推荐文章于 2020-11-13 15:53:06 发布
最新推荐文章于 2020-11-13 15:53:06 发布
阅读量1.1k 收藏
点赞数
文章标签： vector matrix integer output input class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/No_senses/article/details/6465813
版权

真不知怎么说，写了挺久的。

写不写文档以后再说了。

我自己贴出代码来。想必也很多多余不之处。

基本上就是：

自定义整型=》 自定义浮点数=》 自定义的整合数型（继承了以上的两个类）=》自定义向量类 =》 矩阵类

#include<iostream.h>
#include<stdlib.h>
#include<math.h>
class integer{
public:
 integer(int inter0=0){inter=inter0;};
 integer operator +(integer int2){
  integer temp;
  temp.inter=inter+int2.inter;
        return temp;
 };
 integer operator - (integer int2){
  integer temp;
  temp.inter=inter-int2.inter;
        return temp;
 };
 integer operator *(integer int2){
  integer temp;
  temp.inter=inter*int2.inter;
        return temp;
 };
 integer operator /(integer int2){
  integer temp;
  temp.inter=inter/int2.inter;
        return temp;
 };
 void print(){ 
  if(inter< -32768||inter>32767) cout<<"/t overflow, now stop this operate."<<endl;
  else cout<<inter<<endl;
 };
protected:
 int inter;
};
class Real{
public:
 Real(double doub0=0.0){doub=doub0;};
 Real operator +(Real doub2){
  Real temp;
  temp.doub=doub+doub2.doub;
        return temp;
 };
 Real operator - (Real doub2){
  Real temp;
  temp.doub=doub-doub2.doub;
        return temp;
 };
 Real operator *(Real doub2){
  Real temp;
  temp.doub=doub*doub2.doub;
        return temp;
 };
 Real operator /(Real doub2){
  Real temp;
  temp.doub=doub/doub2.doub;
        return temp;
 };
 void print(){ 
  if(doub< -32768.0||doub>32767.0) cout<<"/t overflow, now stop this operate."<<endl;
  else cout<<doub<<endl;
 };
protected:
 double doub;
};

class IntReal: public integer,public Real{
public:
 IntReal(int i=0,double d=0.0):integer(i),Real(d){};
 IntReal operator +(IntReal IR){
  IntReal temp;
  temp.doub=doub+IR.doub;
  temp.inter=inter+IR.inter;
        return temp;
 };
 IntReal operator -(IntReal IR){
  IntReal temp;
  temp.doub=doub-IR.doub;
  temp.inter=inter-IR.inter;
        return temp;
 };
 IntReal operator *(IntReal IR){
  IntReal temp;
  temp.doub=doub*IR.doub;
  temp.inter=inter*IR.inter;
        return temp;
 };
 IntReal operator /(IntReal IR){
  IntReal temp;
  temp.doub=doub/IR.doub;
  temp.inter=inter/IR.inter;
        return temp;
 };
 IntReal operator =(IntReal IR){
        inter=IR.inter;
  doub=IR.doub;
        return *this;
 };
 friend ostream& operator<<(ostream& output,IntReal& R){
  cout<<R.doub<<" ";           //测试时可用cout<<R.inter<<"/"<<R.doub<<" ";
  return output;

 };
 friend istream& operator>>(istream& input,IntReal& R){      //第一次写成了 iostream，错误啊
  double org_num;
  cin>>org_num;
  IntReal Temp(org_num,org_num);
  R=Temp;
  return input;
 };
};

class Vector
{
public:
       Vector(int=1);  //预定义长度为 1 的向量
    Vector(IntReal*,int);
    Vector(Vector&);
    ~Vector();
    IntReal&operator[](int);
    int operator()();
    Vector& operator=(Vector&);
    friend Vector operator+(Vector&,Vector&);
    friend Vector operator-(Vector&,Vector&);
    friend IntReal operator*(Vector&,Vector&);
    friend ostream& operator<<(ostream& output,Vector&);
    friend istream& operator>>(istream& input,Vector&);
    void amount(){
      IntReal amount;
      for(int i=0;i<len;i++)
    amount=amount+v[i];
   amount.Real::print();
    };
private:
     IntReal *v;      //has class  IntReal
  int len;
};
Vector::Vector(int size)
{
 if(size<=0||size>100)
 {
  cout<<"The size of"<<size<<"is fail!/n";
     exit(0);
 }
 v=new IntReal[size];
 for(int i=0;i<size;i++)
  v[i]=0;                     
 len=size;
}
Vector::Vector(Vector& A)
{v=new IntReal(A());
len=A();
for(int i=1;i<A.len;i++)
v[i]=A[i];

}
Vector::Vector(IntReal*B,int size)
{
 if(size<=0||size>100)
    {cout<<"The size of"<<size<<"is fail!/n";
 exit(0);}
 v=new IntReal[size];
 len=size;
 for(int i=0;i<size;i++)
  v[i]=B[i];
}
Vector::~Vector()
{
 delete[]v;
    len=0;
}
IntReal& Vector::operator[](int i)
{
 if(i>=0&&i<len)
    return v[i];
 cout<<"The subscript "<<i<<" is outside!/n";
 exit(0);
}
int Vector::operator()()
{
 return len;
}
Vector operator+(Vector& A,Vector& B)
{
 int size=A();
 IntReal* T=new IntReal[size];
 if(size==B())
 {
  for(int i=0;i<size;i++)
   T[i]=A[i]+B[i];
  return Vector(T,size);
 }
 else
 {
  cout<<"Operator+fail!/n";
  exit(0);
 }
}
Vector operator-(Vector& A,Vector& B)
{
 int size=A();
 IntReal* T=new IntReal[size];
 if(size==B())
 {
  for(int i=0;i<size;i++)
   T[i]=A[i]-B[i];
  return Vector(T,size);
 }
 else
 {
  cout<<"Operator+fail!/n";
  exit(0);
 }
}
IntReal operator*(Vector& A,Vector& B)
{
 if(A()==B())
 {   IntReal T;
  for(int i=0;i<A();i++)
   T=A[i]*B[i]+T;
  return T;
 }
 else
 {
  cout<<"Operator /"*/" fail!/n";
  exit(0);
 }
}
Vector& Vector::operator=(Vector& B)
{ v=new IntReal[B.len];                    
 len=B.len;
  for(int i=0;i<B.len;i++)
   v[i]=B[i];
  return *this;
 
}
ostream& operator<<(ostream& output,Vector& A)
{
 for(int i=0;i<A.len;i++)
  output<<A[i]<<" ";
 return output;
}
istream& operator>>(istream& input,Vector& A)
{
 for(int i=0;i<A();i++)
  input>>A[i];
 return input;
}

 

class Matrix:public Vector{
public:
 Matrix(int=1,int=1);
 Matrix(Matrix&);
 Matrix(Vector*,int=1,int=1);
 friend ostream& operator<<(ostream& output,Matrix&);
 friend istream& operator>>(istream& input,Matrix&);
 Matrix& operator=(Matrix& );
 Matrix transpose();                                        //转置
 friend Matrix operator-(Matrix&,Matrix&);
 friend Matrix operator+(Matrix&,Matrix&);
 friend Matrix operator*(Matrix&,Matrix&);

protected:
 Vector* Row_vector;
 int Row_num,Column_num;

};
Matrix operator+(Matrix &A,Matrix& B){
 if(A.Row_num==B.Row_num&&A.Column_num==B.Column_num){
  Vector* temp=new Vector[A.Row_num];
 for (int i=0;i<A.Row_num;i++){
  temp[i]=A.Row_vector[i]+B.Row_vector[i];
 }
 return Matrix(temp,A.Row_num,A.Column_num);
 }
 else
 {
  cout<<"Operator /"+/" fail! now return the first one/n";
  return A;
 }
}
Matrix operator-(Matrix &A,Matrix& B){
 if(A.Row_num==B.Row_num&&A.Column_num==B.Column_num){
  Vector* temp=new Vector[A.Row_num];
  for (int i=0;i<A.Row_num;i++){
   temp[i]=A.Row_vector[i]-B.Row_vector[i];
  }
  return Matrix(temp,A.Row_num,A.Column_num);
 }
 else
 {
  cout<<"Operator /"-/" fail! now return the first one/n";
  return A;
 }
}

Matrix operator*(Matrix &A,Matrix& B){
 if(A.Column_num==B.Row_num){
  Matrix temp(A.Row_num,B.Column_num);
  B=B.transpose();
  for (int i=0;i<A.Row_num;i++){
   for(int j=0;j<B.Row_num;j++)
    temp.Row_vector[i][j]=A.Row_vector[i]*B.Row_vector[j];
  }
  B=B.transpose();  //还原B矩阵
     return temp;
 }
 else
 {
  cout<<"Operator /"*/" fail! now return the first one/n";
  return A;
 }
}

 


istream& operator>>(istream& input,Matrix& A){
    for(int i=0;i<A.Row_num;i++) //Vector* Row_vector;
  input>>A.Row_vector[i];
 return input;
}
ostream& operator<<(ostream& output,Matrix& A){
 for(int i=0;i<A.Row_num;i++)
  output<<A.Row_vector[i]<<endl;
     return output;
}
//int Matrix::operator()(){
 //return
//}
Matrix& Matrix::operator=(Matrix& A)
{  
                                             // 为什么可以忽略这句呢：Row_vector=new Vector[A.Row_num];                    
 Row_num=A.Row_num;Column_num=A.Column_num;
    for(int i=0;i<A.Row_num;i++)
    Row_vector[i]=A.Row_vector[i];
    return *this;

}

Matrix Matrix::transpose()          //转置
{   Matrix temp(Column_num,Row_num);               
    for(int i=0;i<Column_num;i++)
  for(int j=0;j<Row_num;j++)
   temp.Row_vector[i][j]=Row_vector[j][i];
    return temp;
 
}

 

Matrix::Matrix(int Row,int Column){
 if(Row<=0||Row>=100||Column<=0||Column>=100){
 cout<<"The size of"<<Row<<"or"<<Column<<"overflows";
 exit(0);
 }
 Row_num=Row;Column_num=Column;
 Row_vector=new Vector[Row];
 Vector Row_temp(Column);
 for(int i=0;i<Row;i++){
 Row_vector[i]=Row_temp;
 }
}
Matrix::Matrix(Matrix& A){
 Row_vector=new Vector[A.Row_num];
 Row_num=A.Row_num;Column_num=A.Column_num;
 for (int i=0;i<Row_num;i++){
  Row_vector[i]=A.Row_vector[i];
 }

}
Matrix::Matrix(Vector* Row,int num,int len){
 Row_vector=new Vector[num];
 Row_num=num;Column_num=len;
 for(int i=0;i<num;i++)
  Row_vector[i]=Row[i];

}

 

测试主函数如下：

 

 

 

void main(){
 int r1,r2,c1,c2;
 cout<<"Input the numble of row in Matrix A:/n";
 cin>>r1;
 cout<<"Input the numble of column in Matrix A:/n";
 cin>>c1;
 Matrix A(r1,c1);
 cout<<"Input the elements of Matrix A:/n";
 cin>>A;
 cout<<"Input the numble of row in Matrix B:/n";
 cin>>r2;
 cout<<"Input the numble of column in Matrix B:/n";
 cin>>c2;
 Matrix B(r2,c2);
 cout<<"Input the elements of Matrix B:/n";
 cin>>B;
    Matrix C; 
 cout<<"相加为：/n"<<endl;
 C=A+B;
 cout<<C<<endl;
 cout<<"相减为：/n"<<endl;
 C=A-B;
 cout<<C<<endl;
 cout<<"相乘为：/n"<<endl;
 C=A*B;
 cout<<C<<endl;

}

No_senses
关注
C++实现矩阵，继承vector
qq_31232793的博客
03-07 1705
实现功能： 1.矩阵的两个大括号[][]读取，类似matrix[0][1]这样，也可以赋值matrix[0][1] = 10； 2.矩阵的转置Transposition() 3.矩阵的点成，重载了‘&’符号作为点乘的符号 4.矩阵的叉乘，重载‘*’符号实现 写完大晚上了，有时间再整理注释， #pragma once #include <string> #inc...
13-F. 矩阵类模板（类模板）
bianchengfive的博客
12-22 385
实验13-函数模版与类模版- 题目描述 设计一个矩阵类模板Matrix，支持任意数据类型的数据。 要求至少包含2个成员函数：矩阵转置函数transport、以及打印输出函数print 编写main函数进行测试，调用类的成员函数完成转置和输出。 输入 第一行先输入t，表示有t个测试用例 从第二行开始输入每个测试用例的数据。 首先输入数据类型，I表示int，D表示double，C表示char，接着输入两个参数m和n，分别表示矩阵的行和列 接下来输入矩阵的元素，一共m行，每行n个数据 输出 输出转置后的矩阵 输入
运用模板类完成矩阵的加、减、乘、数乘、转置等运算
11-02
1．建立模板类； 2．实现矩阵的“加”、“减”、“乘”、“数乘”、“转置” ； 3．动态内存分配并用随机数填充。
继承和派生向量类模板和字符串类
11-10
给定一个头文件Vec.h,其中有抽象类模板VECROR设计。还有插入运算符重载、抽取运算符重载的普通c++函数。1、将类模板VECTOR作为基类，通过公共继承派生一个新的类模板Vector（向量类）和一个新的自定义字符串了String。
向量与矩阵的基本运算
11-06
向量与矩阵的基本运算，对于数学向量基本知识的学习很有必要
C++模板矩阵，实现矩阵的常见运算
05-11
实现了一个比较通用的矩阵模板，能够完成+ - * / 求模，求逆， 点乘等多种操作。随便弄点小分，要是没分的直接M我吧。
C++课本的练习题及答案（第八章）
TwcatL_tree
04-07 6013
第8章练习题同步练习8.11．一个大的应用程序，通常由多个类构成，类与类之间互相协同工作, 它们之间有三种主要关系。下列不属于类之间关系的是（    ）。（A）gets-a         ...
C++矩阵运算（终版）.rar
06-11
本项目名为"C++矩阵运算（终版）"，它提供了一个面向对象的矩阵运算库，旨在简化C++中的矩阵和向量操作，类似于MATLAB的简便性。下面将详细介绍这个库可能包含的关键知识点。 1. **面向对象编程**：面向对象编程...
向量矩阵运算
m0_37531129的博客
07-24 1066
import numpy as np 向量运算 a = np.array([1,2]) b = np.array([2,1]) # 向量相乘 dot = sum([i*j for i,j in zip(a,b)]) print('非numpy 计算 向量相乘结果: ',dot) ## 向量相乘numpy 用法 dot1 = np.sum(a*b) dot2 = (a*b).sum() dot3 = np.dot(a,b) dot4 = a.dot(b) dot5 = b.dot(a) print('
用C++写的矩阵运算类
02-23
1. **面向对象编程**：C++是一种支持面向对象编程（OOP）的语言，这个矩阵运算类展示了如何通过封装、继承和多态等OOP特性来组织代码。类定义了一种数据结构（矩阵）并提供了操作这些数据的方法。 2. **类设计**：...
【转】矩阵运算类
05-13
矩阵之间的各种运算，包括求逆，相加，相乘，求行列式，转置等，亲自试用过，可以用
C++练习题及答案（五）
快乐的小小程序猿
06-26 8849
第8章练习题同步练习8.11．一个大的应用程序，通常由多个类构成，类与类之间互相协同工作, 它们之间有三种主要关系。下列不属于类之间关系的是（ ）。（A）gets-a （B）has-a （C）uses-a （D）is-a2．在C++中，类之间的继承关系具有（ ）。（A）自反性 （...
C++矩阵运算（较全面）
love_petrel的博客
07-12 9857
C++矩阵运算，面向对象编程，构建C++矩阵运算库实现包括一维向量、二维矩阵以及三维矩阵的常见操作。
矩阵_矩阵运算
⎝⎝⎝MaximilianLiu⎠⎠⎠的博客
10-09 1065
目录 数乘矩阵矩阵的加法运算矩阵乘法运算矩阵运算基本性质单位阵逆矩阵转置矩阵正交矩阵秩线性方程组高斯消元舒尔补LU分解坐标空间的变换 一个m×n矩阵 当m=n时，A叫做n阶方阵(或n阶矩阵)。 只有一行的矩阵称为行矩阵或行向量;只有一列的矩阵称为列矩阵或列向量 两个矩阵只有在其行数、列数都相同，且所有对应元素都相等时，才是相等的。 矩
C++编程练习 矩阵模板类的实现
Pepsi3333的博客
11-13 1955
C++编程练习 矩阵模板类的实现 前言 通过自定义模板实现了一个矩阵及其运算的Matrix类，并重载了+ - * += -= *= [] 等运算符，但是没有实现列表初始化方式的构造函数。 本文编写的代码可以用来学习使用，涉及到的知识点有模板、构造函数、拷贝构造、虚函数、动态内存分配、运算符重载等等，对初学C++的朋友来说是极好的练手。 代码编写过程中借鉴了https://blog.csdn.net/m0_37772174/article/details/83018940的代码，这篇文章中还实现了矩阵的行变换
8.6 特殊类型的矩阵和向量
很嗨
07-18 3624
有些特殊类型的矩阵和向量是有特别用处的。 对角矩阵（diagonal matrix）只在主对角线上含有非零元素，其他位置都是零。形式上，矩阵DD是对角矩阵，当且仅当对于所有的i≠j,Di,j=0i\ne j,D_{i,j}=0。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值