Assigned in C++

[silver-moon-2000]

Hallo Leute,

ich bräuchte mal Eure Hilfe zu einem absolut einfachen Problem aus der C++-Welt.
Irgendwie stehe ich so dermaßen auf dem Schlauch, dass mir auch eine Suche im Internet keine Erleuchtung brachte.

Vorab: Das Ganze Programm soll auf einem Arduino laufen, daher ist die Sparache nicht Delphi, sondern C++. Auch sind geringer Speicher- & Ram Verbrauch relativ wichtig!
Da das gesamte Programm (für meine Verhältnisse) recht komplex ist, habe ich mich für einen objektorientierten Ansatz entschieden.

Gegeben sei eine Klasse / Library, die ein von mir entwickelten "Shield" (Arduino-Slang für angeschlossene Hardware) steuern soll.
An diesem Shield einer einfachen Bewässerungsteuerung ist auf jeden Fall (unter Anderem) ein Auslassventil angeschlossen, ein Einlassventil ist optional anschließbar, jedoch nicht zwingend nötig.
Wenn das Einlassventil nicht angeschlossen ist, will ich (da Speicherplatz auf dem Arduino rar ist) die die Valve-Instanz inletValve gar nicht erst erzeugen.

Doch wie teste ich nun im weiteren Verlauf des Programmes, ob ich zu Beginn inletValve erzeugt habe oder nicht? Ob ich somit darauf zugreifen darf oder nicht?

In Delphi würde ich das Problem so lösen:

Delphi-Quellcode:

type TFluidWorks = class()
  private
    FInletValve : TValve;
    FOutletValve : TValve;
  public
    constructor Create(_hasInletValve : Boolean);
    procedure switchOn;
end;


TFluidWorks.Create(_hasInletValve : Boolean);
begin
  FOutletValve := TValve.Create(...);
  if _hasInletValve then
    FInletValve := TValve.Create(...);
end;


procedure TFluidWorks.switchOn;
begin
  FOutletValve.switchOn;
  if Assigned(FInletValve) then //<------test, ob FInletValve "gültig"
    FInletValve.switchOn;
end;

Doch leider ist Delphi nicht die Zielsprache In C++ schwebt es mir vor, das Ganze so umzusetzen:

Code:

class FluidWorks {
  public:
    FluidWorks(bool hasInletValve);
    void switchOn();
  private:
    Valve inletValve;
    Valve outletValve;
};


FluidWorks::FluidWorks(bool hasInletValve){
  outletValve = Valve(...);
  if (hasInletValve){
    inletValve = Valve(...);
  }
}

void FluidWorks::switchOn(){
  outletValve.switchOn();
  if (&inletValve != NULL){ //<--------- hier bin ich mir unsicher
    inletValve.switchOn();
  }
}

Ich bin mir nun an der markierten Stelle unsicher: Wie teste ich, ob die Referenz auf inletValve "gültig" ist, genauer gesagt: ob also eine Valve-Instanz namens inletValve existiert?

Die Funktionalität kann ich mangels Arduino-Board nicht testen, alles, was ich derzeit machen kann, ist zu sehen, ob der Compiler durchläuft...
Nur leider ist ein "fehlerfreies" Kompilat nicht gleichbedeutend mit einem "funktionierenden" Programm...

Das Thema https://www.delphipraxis.net/151591-[c-]-assigned.html kenne ich, aber mein Verständnisproblem scheint / grundlegender tiefer zu sein...

(inletValve != NULL) (also ohne den &-Operator) quittiert der Compiler (aus der Arudino-IDE) mit
[pre]
error: no match for 'operator!=' (operand types are 'Valve' and 'int')
[/pre]
(&inletValve != NULL) läuft zumindest durch, aber könnt Ihr mir sagen, ob der Code das tut, was ich von ihm will?

Für eine kurze Antwort bzw. Eure Einschätzung wäre ich dankbar.