Thread: Ouside declaration of a nested struct/class

If you want Motor to be nested inside Car, then what you did was correct. I don't think you can move the definition of Car::Motor out of Car, though you could try that with a forward declaration of Motor in Car to see if it works.

Oh, but you declare a member object of Motor in Car. Even if you could move the definition of Motor outside of Car by forward declaring it in Car, you cannot then declare an object of Motor in Car because you need the definition of a class to declare an object of the class, not merely a forward declaration. Consequently, what you want to do cannot be done either way, so you should stick with what you have now.

Of course, it may also be plausible that Motor shouldn't be nested in Car in the first place, in which case just defining it before Car would suffice.

Given a Car object, you can already invoke the public member functions of the Car object from within member functions of the Motor class, without nesting or friendship. Are you sure that Motor needs to access the internals of Car, especially since you're using the struct keyword (public by default) rather than the class keyword (private by default)?

Originally Posted by serge

MotorFunction needs to call CarFunction, which then does something on Car. Moving struct Motor outside of Car precludes MotorFunction from calling CarFunction.

No, it doesn't. What you need to do is to have the Motor object or member function be able to refer to a Car object, e.g., through a reference parameter.

Note that this holds true even if you nest Motor in Car: the Motor member function still needs a way to refer to a Car object to call CarFunction. However, as a nested class Motor would have access to the internals of Car.

Here is how it might be done:

Code:

#include <iostream>

struct Gauge
{
    explicit Gauge(int dial) : Dial(dial) {}

    int Dial;
};

struct Car;

struct Motor : Gauge
{
    explicit Motor(int dial) : Gauge(dial) {}

    void MotorFunction(int increment, Car& car);
};

struct Car
{
    Car(int foo, int gauge) : Foo(foo), Diesel(gauge) {}

    int CarFunction(int increment)
    {
        return Foo += increment;
    }

    int Foo;
    Motor Diesel;
};

void Motor::MotorFunction(int increment, Car& car)
{
    car.CarFunction(increment);
}

int main()
{
    Car A(1, 2);
    A.Diesel.MotorFunction(5, A);
    std::cout << A.Foo << std::endl;
    return 0;
}

Notice that:

• I declared the Gauge and Motor constructors to be explicit since they take a single parameter, and you probably don't want an implicit conversion through those constructors.
• I forward declared Car before defining Motor because MotorFunction has a Car& parameter.
• I defined MotorFunction after defining Car because MotorFunction calls CarFunction, so the Car class must be defined before MotorFunction can be defined.
• As a matter of purely subjective style, I moved the member variable declarations to the end of the class definitions. This is because if you do make use of private access, typically we would place the members with public access first to indicate that those form the interface, whereas the members with private access tend to be placed towards the end as they are implementation detail.

I note that in your example, you aren't actually using the Dial member inherited from Gauge.