使用向量的矩阵乘法

Question

I'm trying to multiply matrices. This line A[i][j].emplace_back(i*j); cause this error:

IntelliSense: expression must have class type

What's wrong with this code? I also try push_back() function.

#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] is actually just a double, so it doesn't have any member function called emplace_back this is why you get the error you get.

Because you already have the index already you can just place the element in directly:

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;
        }
    }
}

However there's more to it than this, this code won't compile, so always try to compile first and post all errors. A and B are actually empty when they get passed to initialize here so A.size() and B.size() are both zero and hence no initialization actually occurs.

This is a fairly good example of a situation where you want to define your own datastructure for a matrix that contains the dimensional data. This way you won't run into these problems that occur when the size of the dimensions gets lost.

Perhaps something along the lines of:

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;
};

Alternatively you can use nested std::arrays along with a template containing the dimensions.

Answer 2

Here is a template class so vector can be int or 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);