Programm aufteilen

Hallo Zusammen,
folgendes Problem stellt sich mir.
In der IDE hatte ich meine Programme auf verschiedene Tabs verteilt damit es übersichtlicher bleibt.
Aktuell versuche ich mich in platformIO, hier scheint das aber etwas anders zu laufen.
Ich habe schon einiges gelesen wie das in c++ gemacht wird, aber so richtig verstehen tu ich das nicht.
Meine main.cpp liegt im Verzeichnis src In die main.cpp muss ich dann die Datei mit der Pumpen Steuerung mit include einbinden. ich nehme an so: include pumpe.h
Heisst dann die Datei der Pumpe pumpe.h ? oder muss das dann auch eine cpp sein?
In die pumpe.h kommt dann als erstes #pragma once ?
wie geht es dann weiter? kann ich dann wie in der IDE die pumpe mit pumpe(); aufrufen? und in der pumpe.h steht dann void pumpe() und dann kommt mein Code?
Ist das Verhalten dann wie bisher in der IDE, dass der Compiler alles zu einem Programm verwurschtelt, sind die globalen Variablen dann genau so verfügbar?
Sorry für die vielen (wohl blöden) Fragen, aber durch das viele lesen hab ich jetzt gar keinen Plan mehr wie ich mein kleines Problem am besten lösen kann.
Im voraus schon mal besten Dank für Eure Denkanstöße.
Grüße Uwe

Warum stellst du deine Frage nicht in einem "PlatformIO"-Forum ?
Da könntest du sicher schneller eine Antwort erhalten.

@HotSystems, stimmt, daran hab ich überhaupt nicht gedacht.
Aber vielleicht bekommr ich hier ja auch eine Antwort......
ist ja keine platformIO spezifische Frage, sondern eher eine allgemeine Frage in C++

rentneruwe:
@HotSystems, stimmt, daran hab ich überhaupt nicht gedacht.
Aber vielleicht bekommr ich hier ja auch eine Antwort......
ist ja keine platformIO spezifische Frage, sondern eher eine allgemeine Frage in C++

Ok, ich hatte das zwar als platformIO typisch verstanden, muss aber nicht stimmen, da ich selbst nur mit der Arduino IDE arbeite.

Ist das Verhalten dann wie bisher in der IDE, dass der Compiler alles zu einem Programm verwurschtelt, sind die globalen Variablen dann genau so verfügbar?

Jede *.cpp Datei ist eine eigene Übersetzungseinheit.

Damit sich verschiedenen Übersetzungseinheiten eine globale Variable teilen können, muss sie als extern deklariert werden.

Hallo Uwe,
ist dir der Unterschied zwischen einer Deklaration und einer Definition klar? Das ist ( unter so einigem anderen :wink: ) elementar wichtig für das Verständnis dieses Themas.

@ MicroBahner,
naja, hab schon einiges darüber gelesen aber so ganz richtig klar ist mir der Unterschied nicht.
Im richtigen Leben ist der Unterschied klarer, komme ich mit einer definierten Menge zum Zoll, muss ich die deklarieren. :o

Grüße Uwe

Im richtigen Leben ist der Unterschied klarer, komme ich mit einer definierten Menge zum Zoll, muss ich die deklarieren

Die Menge selber ist eine definierte Menge.
Die Papiere der Bestellbestätigung sind die Mittel der Deklaration.

Bei größeren Mengen, deklariert man die Menge beim Zoll, bevor die Menge überhaupt die Grenze passiert hat.
Vorteil:
Der Zoll kann schon lange vorher mit der Menge arbeiten ohne sie je in echt gesehen zu haben.

Selbst der Transportunternehmer bekommt eine Deklarierung der Ware, damit er ein passendes Auto auswählen kann ohne die Ware gesehen zu haben.

Alle Instanzen (Zoll, Transportierer, Lager, Übersetzungseinheiten, Linker, Compiler) wissen was sie zu tun haben, wenn dann doch die Ware eintrifft. Keine fatalen Überraschungen in letzter Sekunde.

Was für eine wunderbar anschauliche Erklärung!

Ja, wirklich eine schöne Erklärung. Und in unserem Fall sind die .h-Dateien die Deklarationspapiere :wink:

rentneruwe:
Meine main.cpp liegt im Verzeichnis src In die main.cpp muss ich dann die Datei mit der Pumpen Steuerung mit include einbinden. ich nehme an so: include pumpe.h
Heisst dann die Datei der Pumpe pumpe.h ? oder muss das dann auch eine cpp sein?
In die pumpe.h kommt dann als erstes #pragma once ?
wie geht es dann weiter? kann ich dann wie in der IDE die pumpe mit pumpe(); aufrufen? und in der pumpe.h steht dann void pumpe() und dann kommt mein Code?

Wie wird das dann praktisch umgesetzt?
Stimmen meine Vermutungen?

rentneruwe:
Wie wird das dann praktisch umgesetzt?
Stimmen meine Vermutungen?

Nicht so wirklich. Wie beim Zoll gehört zur Deklaration natürlich auch die Ware. Die 'Ware' ist bei uns dann die .cpp-Datei. Womit auch klar ist, dass beides zusammenghört - die .h und entsprechende .cpp, die den Programmcode enthält.

Könnte mal freundlicherweise jemand ein Beispiel posten wie das praktisch aus sehen soll?
Ich will ja nur mein Programm aufteilen und damit übersichtlicher machen.
Wenn ich das mal kapiert habe, werde ich es sicherlich nie mehr vergessen :slight_smile:
Vielen Dank für Eure Hilfe

Könnte mal freundlicherweise jemand ein Beispiel posten

v.h

#pragma once
extern int var;  // Deklaration: var ist ein int

main.cpp

#include "v.h"  // damit ist var bekannt und kann in dieser cpp verwendet werden

data.cpp

#include "v.h"  

int var =123;  // Hier ist die Definition und Initialisierung

Das wäre eine Möglichkeit.
Alternativ: alle globalen Variablen werden in main.cpp definiert und Hilfsmodule können sie verwenden

myfuctions.cpp

#include "v.h"  // Zugriff auf irgendwo anders definierte Variable ermöglichen
bool upperEnd() {
  return (var >= 1000) ;
}
bool incr() {
   if (upperEnd()) return false;
   else {var++; return true; }
}

Achtung: bei anderer Reihenfolge der Funktionen incr und upperEnd bräuchte man auch eine Deklaration der Funktion.

z.B. so:

functions.h

#pragma once
#include "v.h" // arbeitet mit den globalen Variablen
bool incr(); // Funktionsdeklaration : hat keine Parameter und liefert true zurück, wenn incrementiert wurde, sonst false
bool upperEnd(); // liefert true, wenn das obere Ende erreicht ist, sonst false

myfunctions.cpp

#include "functions.h"  // Zugriff auf die Deklaration von Funktionen (und Variablen)
bool incr() {
   if (upperEnd()) return false; // Dank Funktionsdeklaration ist diese Funktion hier schon bekannt
   else {var++; return true; }
}
bool upperEnd() {
  return (var >= 1000) ;
}

In der Praxis liefern include Dateien Deklarationen (und möglichst deren Beschreibung) von Funktionen und Variablen. Oder Deklarationen von Klassen mit deren Methoden und Member-Variablen.