Linking functions using simple pointers

Question

I am trying to do something I thought was simple: calling functions that call functions that call functions (from inherited classes) using a chain of pointers. Is there a better way of accomplishing this? Also, in the spirit of C++11, how would I incorporate smart pointers in this example? This example crashes the application:
Here is the sample code, apologies if it looks a little silly:

Actual output (Crashes!):

    almost there...

Desired output:

    almost there...
    hello from function1

f1.h:

    #ifndef FUNCTION_1_H
    #define FUNCTION_1_H
    //f1.h (header file)

    #include <iostream>

    struct f1{

    int _a;
    f1() {}
    void function1();

    };

    #endif

f2.h:

    #ifndef FUNCTION_2_H
    #define FUNCTION_2_H
    //f2.h (header file) 


    #include "f1.h"

    struct f2 : public f1{

    int _b;
    f1* f1_ptr;
    f2() :f1(){}
    void function2();

    };

    #endif

f3.h:

    #ifndef FUNCTION_3_H
    #define FUNCTION_3_H


    #include "f2.h"

    struct f3 :public f2{

    int _c;
    f2* f2_ptr;
    f3() : f2(){}
    void function3();

    };

    #endif

CPPs:

f3.cpp:

    #include "f3.h"


    void f3::function3(){

    //do stuff...
    //e.g. calculate an int Var3
    f2_ptr->function2(/*pass Var3 as argument*/);
    }

f2.cpp:

    #include "f2.h"


    void f2::function2(/*receive Var3*/){

    //do stuff with Var3
    //e.g. maybe use Var3 to calculate an int Var2

    std::cout << "almost there..." << std::endl;
    f1_ptr->function1(/*pass Var2 as argument*/);
    }

f1.cpp:

    #include "f1.h"


    void f1::function1(/*receive Var2*/){

    //take Var2 and use elsewhere
    //or continue linking to other functions
    std::cout << "hello from function1" << std::endl;
    }

main.cpp:

    int main(){

    f3* ptr3 = new f3;
    ptr3->function3();
    //delete ptr3;
    std::cin.get();
    return 0;
    }

Answer 1

The problem is that in the upper classes, the pointers f2* and f1* are not initialized, so when you do f2_ptr->function2(), you are trying to access a member function via an uninitialized pointer, which leads to UB (undefined behaviour). Your code is doing basically this:

#include <iostream>

using namespace std;

struct Base
{
    void f(){cout << "In f" << endl;}
};

struct Derived
{
    Base* ptr;
};

int main()
{
    Derived* foo;
    foo->ptr->f(); //cannot use foo->ptr, it is not initialized
}

So you have to make sure that in the constructors of f3 you initialize the f2_ptr and so on. About smart pointers, you can use std::unique_ptr or std::shared_ptr, the syntax is std::unique_ptr<Foo> pointer( new Foo ) (and similarly for std::shared). It is highly recommended to use them, for example, you HAVE TO initialize them (cannot arrived at this problem if you'd have used smart pointers)

Here is a hint for how to write f3.cpp:

#include "f3.h"

// define the constructor here (and just declare it in the header `f3.h`)
f3::f3() : f2()
{
    auto f2_ptr = std::make_shared<f2>(); 
    // and all our nightmares are over, f2_ptr is now a valid pointer
    // which will automatically release the allocated memory
    // when the reference count is zero
}

void f3::function3()
{
    //do stuff...
    //e.g. calculate an int Var3
    f2_ptr->function2(/*pass Var3 as argument*/);
}

And since I started this, here is a full C++11 example (it uses in-class initialization) with chaining and that uses smart pointers, which works and is basically equivalent to yours:

#include <iostream>
#include <memory>

using namespace std;

struct Base
{
    void f_base()
    {
        cout << "In f_base" << endl;
    }
};

struct Derived
{
    void f_derived()
    {
        cout << "In f_derived" << endl;
    }
    std::shared_ptr<Base> ptrBase = make_shared<Base>();
};

struct DerivedDerived
{
    std::shared_ptr<Derived> ptrDerived = make_shared<Derived>();
};

int main()
{
    DerivedDerived *foo = new DerivedDerived;
    foo->ptrDerived->ptrBase->f_base(); // OK now
}

PS: this may help you understand what's going on When does invoking a member function on a null instance result in undefined behavior?