Question

我正在尝试使用C ++ Vector来做一个Matrix类，但是我不知道为什么函数中“矩阵结果”的内部没有传递给我的对象，而是将其封装在函数中。 >

到目前为止，我只尝试在两个矩阵之间做一个“加法函数”。

我试图使用指针，但是按照这种方式（根据我的知识），我不能以这种方式将函数调用到对象上：

foo.function1(bar1).function2(bar2);

但是使用指针我必须以这种方式调用函数：

foo.function1(bar1);
foo.function2(bar2);
//and so on..

这是我的头文件：

#include <iostream>
#include <vector>

using namespace std;


class Matrix 
{
    public:

        Matrix (int height, int width);

        Matrix add(Matrix m);

        Matrix applyFunction(double (*function)(double));

        void print();


    private:

        vector<vector<double> > matrix;

        int height;
        int width;
};

这是.cpp文件：

Matrix::Matrix(int height, int width)
{
    this->height = height;
    this->width = width;

    this->matrix = vector<vector<double> >(this->height, vector<double>(this->width));
}

Matrix Matrix::add(Matrix m)
{

    Matrix result(this->height, this->width);

    if (m.height== this->height&& m.width== this->width)
    {

        for (int i = 0; i < this->height; i++)
        {
            for (int j = 0; j < this->width; j++)
            {

                result.matrix[i][j] = this->matrix[i][j] + m.matrix[i][j];
            }

            return result;
        }
    }
    else
    {

        cout << "Impossible to do addition, matrices doesn't have the same dimension" << endl;
        return result;
    }
}

Matrix Matrix::applyFunction(double(*function)(double))
{

    Matrix result(this->height, this->width);

    for (int i = 0; i < this->height; i++)
    {
        for (int j = 0; j < this->width; j++)
        {

            result.matrix[i][j] = (*function)(this->matrix[i][j]);
        }
    }

    return result;
}

void Matrix::print()
{

    for (int i = 0; i < this->height; i++)
    {
        for (int j = 0; j < this->width; j++)
        {

            cout << this->matrix[i][j] << " ";
        }

        cout << endl;
    }

    cout << endl;
}

输出应为加法甜菜A B 2x2：

x1 x2

x3 x4

但是计算机只显示零。

Answer 1

您的成员函数都返回一个新对象（它们返回“按值”）。

从链接的用法来看，您似乎实际上是想修改对象并通过引用返回*this。

否则，您将需要以下内容：

auto bar2 = foo.function1(bar1);
auto bar3 = foo.function2(bar2);
// etc

目前这里没有指针。

Answer 2

您可以通过两种变体来实现add

Matrix add(Matrix m)
{
    // optimisation: you don't need separate result, m already IS a copy!
    // so you can just calculate:
    ...
    {
        m.matrix[i][j] += this->matrix[i][j];
    }

    return m;
}

或：

Matrix& add(Matrix const& m)
//                    ^ accept const reference to avoid unnecessary copy
//    ^ returning reference(!)
{
    ...
    {
        // modifies itself!
        this->matrix[i][j] += m.matrix[i][j];
    }

    return *this; // <- (!)
}

现在允许这样做：

Matrix m0, m1, m2;
m0.add(m1).add(m2);
// m0 now contains the result, original value is lost (!)

因此，您不需要像第一个变体那样进行最终分配：

m0 = m0.add(m1).add(m2);
// or assign to a new variable, if you want to retain m0's original values

这是您在问题中所缺少的（因此您没有得到想要的结果）。

也许您想同时拥有两个变体，并且您可以重命名其中之一。但是C ++有一个不错的功能，您可能会更好：操作符重载。考虑普通int：

int n0, n1;
n0 += n1;
int n2 = n0 + n1;

好吧，假设您知道发生了什么事。如果您可以对矩阵做完全一样的事情？其实可以！您需要做的是使运算符超载：

Matrix& operator+=(Matrix const& m)
{
    // identical to second variant of add above!
}

Matrix operator+(Matrix m) // again: the copy!
{
    // now implement in terms of operator+=:
    return m += *this;
}

是的，现在您可以这样做：

Matrix m0, m1, m2;
m0 += m1 += m2;
m2 = m1 + m0;

或者（我更喜欢），您也可以将第二个运算符（operator+）实现为独立功能：

// defined OUTSIDE Matrix class!
Matrix operator+(Matrix first, Matrix const& second)
{
    return first += second;
}

最后：如果尺寸不匹配，则比返回一些虚拟矩阵更好的是抛出一些异常； std::domain_error可能是SizeMismatch之类的候选者，或者您可以定义自己的例外。并且请不要将任何输出输出到控制台或此类运算符的其他位置，这不是任何人期望的，此外，您还可以将控制台输出强加给可能认为不合适的其他人（也许他们想要使用另一种语言输出？）。 / p>

为什么我的函数不会更改对象的属性

2 个答案: