包含纯虚函数的模板类的C ++实现

Question

I'm working on a calculator that has to be able to work on different types of data (even not math data, eventually) but I'm stuck in the implementation of the Complex number class. Here is what I want to achieve:

• An abstract template class called vectorSpace from which I will derive other concrete classes like Complex numbers, Vector s, and so on.

Why do I want to create it like this? Well, the only common characteristic of ALL the vector spaces is that they allow two operations: sum operation with the same type of space, and dot product (or scalar product ? Not sure of the actual name in English) in the same field. The field could be of very different types ( integer , double , strings , etc) so I want to make it with a template . Every derivative class will then specify the data type of the field to the template and implement the virtual operations

• A derivative class Complex that will derive from vectorSpace , specifying double as data type, defining the operations of sum and dot product , and then adding all the rest of the available operations.

This is my code in this moment for vectorSpace class (entirely written in a .h file):

#ifndef VECTORSPACE_H
#define VECTORSPACE_H

template <class T>
class vectorSpace
{
public:
    virtual vectorSpace<T>& sum(const vectorSpace<T>&) const =0;
    virtual vectorSpace<T>& dotProduct(const T&) const =0;
};

#endif // VECTORSPACE_H

In complex.h I have this:

#ifndef COMPLEX_H
#define COMPLEX_H

#include "vectorspace.h"

class Complex : public vectorSpace<double> {
private:
    double re, im;
public:
    Complex(double r=0, double i=0);

    double real() const;
    double imag() const;

    Complex& operator +(const Complex& z) const;
    Complex& sum(const Complex& z) const;
    Complex& operator *(double d) const;
    Complex dotProduct(double d) const;
    //other functions for Complex

};

#endif // COMPLEX_H

and finally the implementation I've done:

#include "complex.h"

Complex::Complex(double r, double i) : re(r), im(i) {}

double Complex::real() const{
    return re;
}

double Complex::imag() const{
    return im;
}

Complex& Complex::operator +(const Complex& z) const{
    Complex *aux = new Complex(); //new is not allowed for an abstract class but it should not be abstract anymore
    aux->re = re + z->re;
    aux->im = im + z->im;
    return *aux;
}

Complex& Complex::sum(const Complex &z) const{
    return *this + z;
}

/* I've tried even with this, but it does not work!!
vectorSpace<double>& Complex:sum(const vectorSpace<double>& z) const{
    return *this + z;
}
*/

Complex Complex::operator *(double d) const{
    Complex aux;
    aux.re = re * d;
    aux.im = im * d;
    return aux;
}

Complex& Complex::dotProduct(const double& d) const{
    return *this * d;
}

This is just the last implementation attempt I've done. I've tried various combinations, but still I can't get my Complex class to get it recognized as concrete instead of abstract. Where do I am doing wrong?

Answer 1

The problem :

You need to override the following pure virtual member methods of the abstract template class vectorSpace in your concrete derived class Complex :

virtual vectorSpace<T>& sum(const vectorSpace<T>&) const = 0;
virtual vectorSpace<T>& dotProduct(const T&) const = 0;

Currently, you provide two overloaded member methods, but these are no overrides (try compiling after adding the override keyword to both of these member methods) due to the use of different return types (ie Complex& != vectorSpace<double>& ):

Complex& Complex::sum(const Complex &z) const {
    return *this + z;
}

Complex& Complex::dotProduct(const double& d) const {
    return *this * d;
}

A possible solution :

Pass Complex as an additional template parameter to the base class vectorSpace . Change the signature of the pure virtual member methods using this additional template parameter's type.

A possible implementation [ Try It Online ]:

template< typename T, typename ValueT >
class VectorSpace {

public:

    virtual const ValueT sum(const ValueT&) const noexcept = 0;
    virtual const ValueT dotProduct(T) const noexcept = 0;
};

class Complex : public VectorSpace< double, Complex > {

private:

    double re, im;

public:

    Complex(double r, double i) noexcept 
        : re(r), im(i) {}

    // Do not worry about the const return values; 
    // C++17's Guaranteed Copy Elision will take care of that.

    const Complex operator+(const Complex& z) const noexcept {
        return Complex(re + z.re, im + z.im);
    }

    const Complex operator*(double d) const noexcept {
        return Complex(re * d, im * d);
    }

    const Complex sum(const Complex& z) const noexcept override {
        return *this + z;
    }
    const Complex dotProduct(double d) const noexcept override {
        // Note that this is not a general dot or inner product.
        // This is just scalar multiplication.
        return *this * d;
    }
};

int main() {
    Complex c(1.0, 2.0); // As concrete as can be ;-)
    return 0;
}

I made a few changes, since your heap allocations are pure overhead and dangerous, and you cannot pass a non- const reference to an instance using a const member method of that instance unless you really want to misuse a const_cast ).