klassenname::klassenname(datentyp startwert){
: m_variable(startwert)
}

macht. Das funktioniert soweit, wenn die Membervariablen einen "primitiven" Datentyp haben. Und wie mache ich das, wenn die Membervariablen Instanzen von ganz anderen Klassen sind? Hab schon stundenlang herumprobiert.

Vielleicht habe ich ja auch einen grundlegenden Designfehler drin. Vielleicht seht ihr ja auf Anhieb den Fehler.

Hier mein konkreter Code:

//integrator.cpp
#include "integrator.hpp"

// integrator
integrator::integrator(double u0)
: m_u(u0)
{
    update_step(); //Initializing
}

integrator::~integrator() {}

double integrator::update_calc(double u_in)
{
    m_u = u_in;
    update_step();
    return m_y;
}

void integrator::update_step()
{
    m_y = m_y + m_u;
}

//integrator.hpp
#ifndef INTEGRATOR_HPP
#define INTEGRATOR_HPP

class integrator
{
    public:
        integrator(double u0);
        virtual ~integrator();

        double update_calc(double u_input);

    private:
        double m_u;
        double m_y;
        double m_u0;

        void update_step(void);
};

#endif // INTEGRATOR_HPP

//PT1.cpp

#include "PT1.hpp"

PT1::PT1(double a, double b, double u0)//: integrator(u0)
: m_a(a), m_b(b), m_u0(u0)//, integrator(u0)
{
    this->m_integrator1->Setu0(u0);
    this->m_integrator1->Setk(1.0);
    m_u = m_u0;
    m_y = m_u;
    update_step();
}

PT1::~PT1(){}

double PT1::update_calc(double u_in)
{
    m_u = u_in;
    update_step();
    return m_y;
}

void PT1::update_step() //core PT1 transfer function
{
        m_y = m_integrator1->update_calc(1/m_a*(m_u-m_b*m_y));
}

//PT1.hpp
#ifndef PT1_HPP
#define PT1_HPP
#include "integrator.hpp"

class PT1
{
    public:
        PT1(double a, double b, double u0);
        virtual ~PT1();

        double update_calc(double u_input);

    private:
        //input and output signals
        double m_u;
        double m_y;

        //system parameters
        double m_a;
        double m_b;

        //initial conditions
        double m_u0;

        //subsystems
        integrator * m_integrator1;

        //transfer function
        void update_step(void);

};

#endif // PT1_HPP

//main.cpp

Compiler findet keine Fehler/Warnungen.

int main()
{
integrator integrierer(1.0); //funktioniert

PT1 lowpass(1.0,1.0,0); //Programm stürzt ab

}

Ups, noch 'ne Kleinigkeit:
Habe der Übersicht halber alle Get und Set-Methoden hier herausgelöscht.

this->m_integrator1->Setu0(u0); 
    this->m_integrator1->Setk(1.0);

würde dann natürlich nicht funktionieren. Denkt euch die oben Zitierten wegkommentiert oder alle Get und Set-Methoden als vorhanden.

Warum wendest du nicht dein allgemeines Wissen an?

Hast 'nen Tipp?

Muss ich die Klasse "Integrator" an die Klasse "PT1" vererben oder ist das so schon ok, wie ich das im Prinzip gemacht habe?