使用向量的矩阵乘法

Question

我正在尝试将矩阵相乘。 这行A[i][j].emplace_back(i*j); 导致此错误：

IntelliSense：表达式必须具有类类型

此代码有什么问题？ 我也尝试push_back（）函数。

#include "stdafx.h"
#include <iostream>
#include <vector>

using namespace std;
using matrix = vector<vector<double>>;

matrix multiple(matrix A, matrix B);
void initialize(matrix& A, matrix& B);


int _tmain(int argc, _TCHAR* argv[])
{
    matrix A;
    matrix B;
    initialize(A, B);
    matrix C = multiple(A, B);
    return 0;
}

matrix multiple(matrix A, matrix B)
{
    matrix C;
    for (int i = 0; i < A.size(); ){
        for (int j = 0; j < B.size(); ){
            for (int k = 0; k < A.size();k++)
                C[i][j] += A[i][k] * B[k][j];
        }
    }
    return C;
}

void initialize(matrix& A, matrix& B)
{
    for (int i = 0; i < A.size(); i++){
        for (int j = 0; j < B.size(); j++){
            A[i][j].emplace_back(i*j);
            B[i][j].emplace_back(i*j);
        }
    }
}

Answer 1

A[i][j]实际上只是一个double，因此它没有任何名为emplace_back成员函数，这就是为什么您得到错误的原因。

因为您已经有了索引，所以可以直接将元素放入：

void initialize(matrix& A, matrix& B)
{
    for (int i = 0; i < A.size(); i++){
        for (int j = 0; j < B.size(); j++){
            A[i][j] = i*j;
            B[i][j] = i*j;
        }
    }
}

但是，除此之外，此代码将无法编译，因此请始终先编译并发布所有错误。 A和B在传递给此处进行初始化时实际上为空，因此A.size()和B.size()均为零，因此实际上没有初始化发生。

这是一个很好的例子，说明了您要为包含维数据的矩阵定义自己的数据结构的情况。 这样，您就不会遇到尺寸丢失时出现的这些问题。

也许是这样的：

struct Matrix{
Matrix(unsigned int rows, unsigned int cols):
    m_rows(rows),
    m_cols(cols)
{ 
    for(unsigned int i = 0: i < m_cols; ++i){
        m_data.push_back(vector<double>(m_rows));
    }
}

unsigned int m_rows;
unsigned int m_cols;
vector<vector<double>> m_data;
};

或者，您可以使用嵌套的std::arrays以及包含维度的模板。

Answer 2

这是一个模板类，因此vector可以是int或double

template <class T>
std::vector <std::vector<T>> Multiply(std::vector <std::vector<T>> &a, std::vector <std::vector<T>> &b)
{
    const int n = a.size();     // a rows
    const int m = a[0].size();  // a cols
    const int p = b[0].size();  // b cols

    std::vector <std::vector<T>> c(n, std::vector<T>(p, 0));
    for (auto j = 0; j < p; ++j)
    {
        for (auto k = 0; k < m; ++k)
        {
            for (auto i = 0; i < n; ++i)
            {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return c;
}



std::vector <std::vector<double>> a (2, std::vector<double>(2));
a[0][0] = 1;
a[0][1] = 2;
a[1][0] = 3;
a[1][1] = 4;

std::vector <std::vector<double>> b(2, std::vector<double>(2));
b[0][0] = 5;
b[0][1] = 6;
b[1][0] = 7;
b[1][1] = 8;

auto c = Multiply(a, b);