problems using inheritance

[KarinaErlang]

Hi forum,

I am new to C++ and have the following problem. I create a class A from which I derive several other classes B1, B2, ... via inheritance. A member function f of A computes a specific value (property) V of the things I am dealing with. B1, B2, ... all have this property. I thought, "Thank god there is inheritance, now I don't have to write the same member function again and again for every B class." However, the property I am computing in this member function depends on another property specific to the derived classes. Lets call this property P... so P(B1) is different from P(B2) etc. In the main I want to initialize objects from the derived classes b1, b2 etc and call b1.f, b2.f etc. I need to achieve that this function now uses the specific properties P(B1), P(B2) of the derived classes and not the one of the basis class. As f is defined in the scope of A it always uses P(A).

My constraints are:
1. the function cannot take further input arguments (no objects by reference etc)
2. I don't want to redefine f in all of the derived classes (I want f not to appear in the definition of the derived classes).

I hope this makes sense. Thanks for your help guys.

[CornedBee]

If all properties are of the same type, you can add a virtual function that returns a reference to the correct property. Then override that virtual function in every derived class and keep the rest of the computation in A.

[KarinaErlang]

Thanks for your answer. I tried using virtual functions for this problem. But I don't know how to return a reference to the correct property. Could you give me a hint how this would look like in code?

[Mozza314]

Returning by reference is pretty simple. It's also super cool and you'll come across uses for it time and again when you get really involved in this stuff.

e.g.:

int& GetSmallest(vector<int>& v)
{
    assert(!v.empty());
    vector<int>::iterator smallest = v.begin();
    
    vector<int>::iterator it = smallest;
    ++it;
    for (; it != v.end(); ++it)
    {
        if (*it < *smallest)
            smallest = it;
    }
    
    return *smallest;
}

This returns not exactly the smallest value in the vector, but a reference to the smallest value in the vector. So you could do something like this:

// v contains {5, 3, 7, 4}
++GetSmallest(v);
// v contains {5, 4, 7, 4}

[laserlight]

This returns not exactly the smallest value in the vector, but a reference to the smallest value in the vector.

Not a terribly important point with respect to the context of your example, but you could have used std::min_element instead of writing the loop yourself.

[whiteflags]

It's probably due to the original posters vagueness, but I haven't heard of references to class members (properties). I thought there were only pointers to members. So, if that's what this is about, then I'm not sure how discussing references will help.

[Mozza314]

I thought there were only pointers to members.

Seems like a strange thing to say. There's nothing stopping you from doing this (although it is bad practice):

#include <iostream>

class Weird
{
private:
    int x;

public:
    int& Get() { return x; }
    void Print() { std::cout << x << std::endl; }
}

int main()
{
    Weird w;
    w.Get() = 5;
    w.Print(); // Outputs 5
    
    return 0;
}

[whiteflags]

Well that's not precisely what I was thinking but OK.

Pointers to members are actually like this:

Weird::*memptr = &Weird::x; // x is public

It's a fair bit more restricted, and I haven't heard of and am apparently right in thinking that there isn't a reference analog. Not that I have a better idea, but it seems altogether strange. For some reason I think we aren't getting a full picture.

[laserlight]

It's a fair bit more restricted, and I haven't heard of and am apparently right in thinking that there isn't a reference analog. Not that I have a better idea, but it seems altogether strange. For some reason I think we aren't getting a full picture.

I think that you're thinking of "property" as in "member variable", but in this case KarinaErlang stated that it is a domain specific term for some computed value(s). As such, CornedBee's suggestion should be correct: the properties P(B1), P(B2), etc, specific to the derived classes B1, B2, etc, are computed in virtual functions that are called by the non-virtual member function of the base class A that computes the property V. As such, V will be computed using P(B1), P(B2), etc, accordingly, not with P(A) (except when it really is called on an object of type A, not of a derived class type).

If P does not need to be exposed as part of the interface, this would effectively be an instance of the non-virtual interface idiom since it could be made private.

[CornedBee]

I simply mean this:

class A {
  virtual int& getProperty() = 0;

public:
  void foo() {
    int& prop = getProperty();
    // do some calculation
    prop = calculation;
  }
};

class B1 : public A {
  int myProp;

  int& getProperty() { return myProp; }
};

class B2 : public A {
  int hereProp;

  int& getProperty() { return hereProp; }
};

class B3 : public A {
  int someProp;

  int& getProperty() { return someProp; }
};

And yes, the function is intentionally private.

[Mozza314]

I simply mean this:
And yes, the function is intentionally private.

If I can just offer a suggestion, I think it's good practice to always write "virtual" in front of any member which is implicitly virtual, i.e.:

class A {
  virtual int& getProperty() = 0;

public:
  void foo() {
    int& prop = getProperty();
    // do some calculation
    prop = calculation;
  }
};

class B1 : public A {
  int myProp;

  virtual int& getProperty() { return myProp; }
};

class B2 : public A {
  int hereProp;

  virtual int& getProperty() { return hereProp; }
};

class B3 : public A {
  int someProp;

  virtual int& getProperty() { return someProp; }
};

[CornedBee]

Matter of taste. I personally don't care about that.