C++ Anfängerfrage struct

Was machst Du mit dem letzten Strukturelement? Das hat einen anderen 
Typ.

Amsonsten könnte man mit offsetof() etwas reinschießen.
Aber wozu ?

Ohne Reflection 
(https://en.wikipedia.org/wiki/Reflection_(computer_programming)) kann 
man aktuell um eine komplett generische Lösung nur herum arbeiten. Was 
aber Beispielsweise möglich wäre, wäre compile-time Strings zur 
Identifizierung zu übergeben. Das hätte zumindest keinen Runtime 
Overhead:

1

template<char... Cs>

2

struct string {};

3

4

template<typename T, T... Cs>

5

constexpr string<Cs...> operator""_s() {

6

  return {};

7

};

8

9

struct Parameter {

10

    int belichtungszeit;

11

    int empfindlichkeit;

12

    int blende;

13

    int ausloesezeit;

14

    bool blitz;

15

};

16

17

struct Kamera {

18

    template<char... Cs, typename T>

19

    Kamera& set(string<Cs...>, T&& t) {

20

        if constexpr(std::is_same_v<string<Cs...>, decltype("Belichtungszeit"_s)>)

21

            p.belichtungszeit = t;

22

        else if constexpr(std::is_same_v<string<Cs...>, decltype("Empfindlichkeit"_s)>)

23

            p.empfindlichkeit = t;

24

        else if constexpr(std::is_same_v<string<Cs...>, decltype("Blende"_s)>)

25

            p.blende = t;

26

        else if constexpr(std::is_same_v<string<Cs...>, decltype("Ausloesezeit"_s)>)

27

            p.ausloesezeit = t;

28

        else if constexpr(std::is_same_v<string<Cs...>, decltype("Blitz"_s)>)

29

            p.blitz = t;                        

30

31

        return *this;            

32

    }

33

34

    Parameter p;

35

};

36

37

int main() {

38

    Kamera k;

39

40

    k.set("Belichtungszeit"_s, 10)

41

     .set("Empfindlichkeit"_s, 42)

42

     .set("Blende"_s, 9)

43

     .set("Blitz"_s, true);

44

}

Empfehlen würde ich trotzdem eher den klassischen Ansatz, vielleicht 
durch verkettete Funktionsaufrufe etwas verschönert. Im Normalfall nimmt 
einem eine vernünftige IDE die Arbeit fürs erzeugen von gettern und 
settern ab.

1

struct Kamera {

2

    Kamera& belichtungszeit(int b) {

3

        p.belichtungszeit = b;

4

        return *this;

5

    }

6

7

    Kamera& empfindlichkeit(int e) {

8

        p.empfindlichkeit = e;

9

        return *this;

10

    }

11

12

    Kamera& blende(int b) {

13

        p.blende = b;

14

        return *this;

15

    }

16

17

    Kamera& ausloesezeit(int a) {

18

        p.ausloesezeit = a;

19

        return *this;

20

    }        

21

22

    Kamera& blitz(bool b) {

23

        p.blitz = b;

24

        return *this;

25

    }

26

27

    Parameter p;

28

};

29

30

// Klassisch

31

int main() {

32

    Kamera k;

33

34

    k.belichtungszeit(10)

35

     .empfindlichkeit(42)

36

     .blende(9)

37

     .blitz(true);

38

}

Dein Ansatz scheint mir sehr datengetrieben zu sein:
Array mit Structen die Ints enthalten...
Wenn du C++ programmierst, wäre ein objektorientierter Ansatz
vielleicht besser, weil nach 1 Jahr liest sich dieser Code

1

Parameter &params = myParameterDictionary["daylight"];

2

params.SetBelichtungszeit( 4711 );

besser als dieser hier

1

SetParameter( 13, 42, 4711 );

(alles fiktive Werte zur Veranschaulichung).

Ich würde die Parameter in eine Klasse packen

1

class Parameters

2

{

3

private: 

4

  int Belichtungszeit;

5

  ...

6

public:

7

  void SetBelichtungszeit( const int zeit );

8

  int GetBelichtungszeit() const;

9

  ...

10

};

Instanzen dieser Klasse würde ich in einem STL-Container verwalten

1

#typedef std::map<std::string, Parameters> ParameterDict;

Dann kann man so darauf zugreifen:

1

ParameterDict myParameterDict;

2

// parameter einlesen etc.

3

...

4

Parameters &myDaylightParams = myParameterDict["daylight"];

5

int daylightBelichtungszeit = myDaylightParams.GetBelichtungszeit();

merciless

Bert3 schrieb:
> @Klaus:
>
> Bewertung der Lösungen von:
>
> "Vincent H.: Perfekte Beispiele das es unsagbar viele Möglichkeiten gibt
> um in C++ ein Problem zu lösen - oder auf die dunkle Seite der Macht zu
> rutschen - das 1. Beispiel ist "nice" - was zum zeigen für C++03
> Anhänger und das mit der Verkettung ist auch nur "sieht anders aus" ist
> aber nicht wirklich Standard um dein einfaches Problem so zu lösen - ich
> würde dir auf die Finger hauen wenn du mir so was kommst :)

Und was genau is da jetzt schlechter als an

1

void setXYZ(int);

?

Bert3 schrieb:
> "Dirk K.": Klar kannst du deine Parameter-Sätze in eine Map stecken und
> per String addressieren - aber du kannst auch einfach nur die
> Parameter(s?) Klasse ohne die Map verwenden

Der TO hat davon gesprochen, mehrere Parametersätze
(Strukte) in einem Array vorzuhalten. Ich wollte nur
deutlich machen, dass ich eine std::map für den geeigneteren
Container halte.

merciless

Klaus schrieb:
> void SetParameter(int ArrayIndex, #Eintrag aus dem struct# , int Wert)

du musst nicht für jeden struct-Element eine set-Funktion schreiben. Was 
mir vorschwebt ist:

void SetParameter(int * Element, int Wert)
{
   *Element = Wert;
}

Aufruf wäre dann:

SetParameter(&array[i].Belichtungszeit, 10);

wenn du in c++ programmierst, kannst du diese Funktion überladen und 
auch den bool beschreiben:

void SetParameter(bool * Element, bool Wert)
{
   *Element = Wert;
}

Der Aufruf wäre derselbe. also, fas derselbe:

SetParameter(&array[i].Blitz, TRUE);

Bert3 schrieb:
> Was soll den bitte (fuer seinen Fall) der Sinn hinter einer Funktion
> sein die nichts anderes ist als eine Zuweisung - null unterschied dazu -
> nur mehr schreibarbeit - gilt hier im forum fast nur noch die regel:
> wenn es kompiliert und laeuft ist es gut und sollte praesentiert werden?

vielleicht geht es hier dem fragenden ums Prinzip, um die 
Funktionsweise. Er ist ja Anfänger...

Sein Fall ist vielleicht gar nicht mal so simpel. Das wissen wir nicht. 
Er hat vielleicht sein Problem aufs wesentliche runtergebrochen und eine 
konkrete Frage daraus gemacht.

Wie dem auch sei, er kennt jetzt sowohl Ihren Standpunkt, als auch 
einige Lösungsmöglichkeiten bei solchen Problemstellungen...

Bert3 schrieb:
> Er braucht einfache Set und Gets - thats it

nun braucht er oder braucht er nicht, die Set und Get?

Bert3 schrieb:
> Das von dir gezeigte Beispiel erfüllt 1. keinen Zweck

Der Zweck ist: Einen Wert einem Element eines struct aus einem array 
zuzuweisen. Und das tut es. Man kann den Aufruf einzeln anwenden, oder 
in eine Schleife packen.

Bert3 schrieb:
> ist 2. sogar für
> den Nicht-Zweck zu kompliziert geschrieben

noch einfacher geht's hier gar nicht, nur noch direkt, ohne eine 
Unterfunktion daraus zu basteln, was du vorschlägst.

noch mal, ich bin nicht gegen das direkte Schreiben. Nur wenn es 
unbedingt sein muss (Unterfunktion), z.b. wenn das Schreiben aus einem 
anderen Modul passieren soll und die Schnittstelle eben nur aus 
Funktionen zu bestehen hat. Dann ist mein Beispiel die erste Wahl, 
zumindest für mich. Wer mir noch bessere/elegantere/schönere/... Lösung 
zeigen möchte - ich lerne gerne was dazu!

Bert3 schrieb:
> deine GetParameter Funktion lass ich mal weg weil die sich in
> Sinnlosigkeit nicht mehr übertreffen lässt

welche GetParameter Funktion? du verwechselst mich mit jemanden!

Bert3 schrieb:
> Dem Thread-Starter war schon nach dem 3. Post klar das er wohl in die
> falsche Richtung denkt und einfach simple Setter/Getter braucht (weil
> ehr von C++ spricht) - wo ich ihm zustimme

und dennoch macht er die Unterfunktionen. Und du stimmst im auch zu. 
Also macht er eine Set-Funktion pro Element des structes. Mein Vorschlag 
ist EINE (evtl überladene) Set-Funktion für alle Elemente des structes.

Konstantin G. schrieb:
> Bert3 schrieb:
>> Das von dir gezeigte Beispiel erfüllt 1. keinen Zweck
>
> Der Zweck ist: Einen Wert einem Element eines struct aus einem array
> zuzuweisen. Und das tut es.

Das tut eine einfache Zuweisung ohne diese Funktion genauso gut. Die 
Funktion macht es nur umständlicher, ohne jeglichen Nutzen.
Setter und Getter sind normalerweise dazu da, dass ich z.B. darin 
Vorbedingungen prüfen kann oder nötige Aktionen auslösen, und damit ich 
die interne Struktur der Daten auch ändern kann, ohne das Interface mit 
ändern zu müssen. Naturgemäß ist das nicht für jedes Element eines 
bestimmten Typs gleich, daher braucht man für jedes einen eigenen Setter 
und Getter.
Deine Funktion erfüllt daher keinen dieser Zwecke und ist somit 
vollkommen überflüssig.

> Bert3 schrieb:
>> ist 2. sogar für den Nicht-Zweck zu kompliziert geschrieben
>
> noch einfacher geht's hier gar nicht, nur noch direkt, ohne eine
> Unterfunktion daraus zu basteln, was du vorschlägst.

Richtig.

> noch mal, ich bin nicht gegen das direkte Schreiben. Nur wenn es
> unbedingt sein muss (Unterfunktion), z.b. wenn das Schreiben aus einem
> anderen Modul passieren soll und die Schnittstelle eben nur aus
> Funktionen zu bestehen hat.

Sie besteht aber leider nicht nur aus Funktionen, denn du musst ja die 
Adresse der internen Variablen, die du beschreiben willst, als Parameter 
übergeben. Soll die Schnittstelle unbedingt nur aus der Funktion 
bestehen, und man will wirklich nur eine Funktion pro Typ, dann wäre 
eher die Variante mit einem enum und in der Funktion dann mit 
switch/case zu bevorzugen. So braucht der Aufrufer dann wenigstens keine 
Interna der Struktur zu kennen.

Rolf M. schrieb:
> Sie besteht aber leider nicht nur aus Funktionen, denn du musst ja die
> Adresse der internen Variablen, die du beschreiben willst, als Parameter
> übergeben.

stimmt

Rolf M. schrieb:
> So braucht der Aufrufer dann wenigstens keine
> Interna der Struktur zu kennen.

stimmt, der muss den Aufbau der Struktur kennen...

Also als reiner Setter eignet sich das nicht, habt ja Recht. Aber 
vielleicht wenn er da noch etwas code mit rein packt, irgendwelche 
Umrechnungen oder so.
Ich habe mich einfach nur auf die Fragestellung konzentriert. Er wollte 
ja eine allgemeine Unterfunktion, wie man's machen kann..

Dr. Sommer schrieb:
> Was ist denn der Unterschied zwischen einer Funktion und einer
> Unterfunktion?

Eigentlich keiner, nur dass die Unterfunktion von der Funktion 
aufgerufen wird.
Bei Personenhierarchien ist es ähnlich: 
https://www.youtube.com/watch?v=KFXcUr8jEsw

Dr. Sommer schrieb:
> Was ist denn der Unterschied zwischen einer Funktion und einer
> Unterfunktion?

Ironie???

Dr. Sommer schrieb:
> Johnny B. schrieb:
>> Eigentlich keiner, nur dass die Unterfunktion von der Funktion
>> aufgerufen wird.
>
> Dann sind eigentlich alles Unterfunktionen bis auf den Reset-Handler des
> (ROM-)Boot-Codes, da der von der Hardware statt einer anderen Funktion
> "aufgerufen" wird?

Absolute Sichtweise, nicht gerade praktikabel, oder?

Hallo,

ich lehne mich mal aus dem Fenster und behaupte, dass es das Wort 
„Unterfunktion” nicht gibt. Ich denke, das ist ein verdödelter 
Anglizismus.

Damals (TM) gab es ja GOSUB in Basic oder subroutine in Fortran, was ja 
auf ein "unter" hindeutet.

Diese ausführbaren Untereinheiten hießen zum Beispiel Unterprogramm, ein 
Wort, dass aber in meiner Erinnerung recht schnell unmodern wurde, 
Prozedur oder Funktion kamen in Mode, auch wenn zB in Fortran subroutine 
nicht das selbe wie function ist.

So oder so bezeichnete Funktion beim Programmieren schon immer eine 
ausführbare Untereinheit. Unter-Funktion ist also doppelt gemoppelt und 
einfach eine gedanklich schlampige Reminiszenz an Dinge wie subroutine 
oder Unterprogramm.

Wenn überhaupt würde das Wort Sinn ergeben für ein Lambda im Lambda oder 
für nested functions in Python oder Swift oder so ...

So sehe ich das.

Vlg

 Timm

Timm R. schrieb:
> ich lehne mich mal aus dem Fenster und behaupte, dass es das Wort
> „Unterfunktion” nicht gibt. Ich denke, das ist ein verdödelter
> Anglizismus.

Vermutlich ist es eine Mischung aus "Funktion" und dem bei manchen 
Programmieranfängern der "alten Schule" beliebten "Unterprogramm".

Der Begriff wurde vor etlichen Jahrzehnten gelehrt, damals, als die 
Sprache mit dem "GOSUB" der dernier cri war.