ZeigerArray auf Funktionen nachträglich als ganzes umschreiben

S. Hager Gast #1242526 
Hallo!

Ich habe eine Frage zu Funktionszeigern:
Das initialisieren am Anfang klappt gut, ich kann alle Funktionen in das 
Array schreiben. Will ich aber zur Laufzeit alle Funktionen im Array 
ändern, so kann ich es nur einzeln machen und nicht gemeinsam in 
geschwungener Klammer.



typedef void keyfunction(void);

void set1(void);
void set2(void);

keyfunction *key_call[MAXKEYS]={ set1, set2};  // hier geht es



Wenn ich aber zur Laufzeit das machen möchte spinnt der Compiler rum und 
ich hab keine Ahnung warum:

void main(){
...

key_call = {set2, set1}; // A: das lässt mir der Compiler so nicht 
durchgehen

key_call[0] = set2; // B: das jedoch schon
key_call[1] = set1; // B: und das somit auch


wenn ich aber viel zum uminitialiseren habe wird das so langweilig und 
es ist nicht so elegant. Geht A überhaupt zur Laufzeit?

Weder in der Literatur noch in google konnt ich eine Antwort darauf 
finden, ich würde mich freuen wenn mir jemand weiterhelfen könnte.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Langsamer Modus Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Melden Danke
Klaus W. #1242545 
Das Initialisieren mit {} geht nur beim Initialisieren, daher der Name.
Eine spätere Zuweisung geht wie gesagt nicht mit {}.

Falls du aber die Zuweisungen nicht vollkommen willkürlich durcheinander
machen musst, sondern beispielsweise zwischen einigen wenigen, vorher
bekannten Konfigurationen umschalten willst, kannst du dir diese
Konfigurationen in je einem Feld von Zeigern ablegen.
Zum Umschalten gibt es dann zwei Möglichkeiten:
- in dein eigentliches Feld, über das gesprungen wird, jeweils
  eines der vorkonfigurierten umkopieren, oder
- das Springen über eine weitere Indirektion machen, also einen
  neuen Zeiger auf das jeweils aktuelle Feld mit den Konfigurationen
  richten und darüber und einen Zeiger darin springen.
  Beispiel:
1
#include <stdlib.h>

2
#include <stddef.h>

3
#include <stdio.h>

4


5
#define MAXKEYS    2

6


7
typedef void (*keyfunction_t)(void);

8


9
void set1(void);

10
void set2(void);

11


12
void set1(void)

13
{

14
  printf( "ich bin set1\n" );

15
}

16


17
void set2(void)

18
{

19
  printf( "ich bin set2\n" );

20
}

21


22


23


24
// mehrere Zeigertabellen:

25
keyfunction_t key_call_Konfiguration_Vollmond[MAXKEYS]={ &set1, &set2 };

26
keyfunction_t key_call_Konfiguration_Neumond [MAXKEYS]={ &set2, &set1 };

27


28
// die jeweils aktuelle Tabelle:

29
keyfunction_t *p_key_call_Konfiguration_aktuell = key_call_Konfiguration_Vollmond;

30


31


32
// ruft zur Demo alle Funktionen der aktuellen Tabelle auf

33
void tuwas()

34
{

35
  // Aufruf der Funktionen der aktuellen Tabelle über

36
  // p_key_call_Konfiguration_aktuell, um in das richtige Feld zu

37
  // kommen und darin über Index [0] oder [1]

38
  p_key_call_Konfiguration_aktuell[0]();

39
  p_key_call_Konfiguration_aktuell[1]();

40
}

41


42


43
int main( int nargs, char **args )

44
{

45
  printf( "jetzt ist Neumond:\n" );

46
  p_key_call_Konfiguration_aktuell = key_call_Konfiguration_Vollmond;

47
  tuwas();

48


49
  printf( "jetzt ist Vollmond:\n" );

50
  p_key_call_Konfiguration_aktuell = key_call_Konfiguration_Neumond;

51
  tuwas();

52


53
  return 0;

54
}

  Egal, wieviele Einträge in dem Feld jeweils stehen, muss beim
  Umschalten nur ein Zeiger umgesetzt werden.
  Das ist zum einen schnell und zum zweiten sogar atomar.
Antwort Zitieren Bearbeiten Löschen Melden Danke
S. Hager Gast #1242672 
Danke für eure schnellen Antworten, Super :)

Ich hab irgendwie vermutet dass es mit {} nicht zur Laufzeit geht, denn 
nirgends wo ich nachgesehen habe konnte ich so etwas sehen.

@ Klaus Wachtler:

Danke für dein schönes Codebeispiel, auf diese Art und Weise werde ich 
es auch machen. Alle Zuweisungen sind zur Laufzeit bekannt und sollten 
je nach Anwendung umgeschaltet werden.

Wie mir gerade einfällt brauchen nicht immer alle sondern nur 
aufeinander folgende geändert werden. Das geht aber genauso, ich darf 
halt auf den Ziel-Zeiger nicht beim Element 0 zu schreiben beginnen 
sondern etwas später mit einem offset von +X Elemente.
Antwort Zitieren Bearbeiten Löschen Melden Danke
S. Hager Gast #1242679 
KORREKTUR meines letzten Postings:

Was ich zum Schluss geschrieben habe geht nicht, ich kann nicht einen "4 
Elemente langen Zeiger" teilweise über einen "8 Elemente langen Zeiger" 
ab Element 4 reinschreiben. Das geht vielleicht bei strings wo man 
Schritt für Schritt alle Zeichen abarbeitet, aber nicht wenn man die 
Adresse eines Zeigers auf andere Daten zeigen lässt - da es ja nur eine 
Adresse gibt.
Antwort Zitieren Bearbeiten Löschen Melden Danke
Klaus W. #1243127 
Was soll nicht gehen? In C soll etwas mit Zeigern nicht gehen?

Es gibt natürlich keine "8 Elemente langen Zeiger" oder "4
Elemente langen Zeiger", aber dafür Zeiger auf 4 oder 8 Elemente.

Und einen Zeiger kann man auf jedes der Elemente eines Feldes zeigen
lassen, warum nicht auch auf die oberen 4 von 8 Elementen?

Das Beispiel so umgebaut, daß es ein Feld mit 8 Zeigern auf Funktionen
hat und tuwas() einmal die unteren 4 benutzt und dann die oberen 4:
1
#include <stdlib.h>

2
#include <stddef.h>

3
#include <stdio.h>

4


5
#define MAXKEYS    8

6


7
typedef void (*keyfunction_t)(void);

8


9
void set1(void);

10
void set2(void);

11
void set3(void);

12
void set4(void);

13
void set5(void);

14
void set6(void);

15
void set7(void);

16
void set8(void);

17


18
void set1(void)

19
{

20
  printf( "ich bin set1\n" );

21
}

22


23
void set2(void)

24
{

25
  printf( "ich bin set2\n" );

26
}

27


28
void set3(void)

29
{

30
  printf( "ich bin set3\n" );

31
}

32


33
void set4(void)

34
{

35
  printf( "ich bin set4\n" );

36
}

37


38
void set5(void)

39
{

40
  printf( "ich bin set5\n" );

41
}

42


43
void set6(void)

44
{

45
  printf( "ich bin set6\n" );

46
}

47


48
void set7(void)

49
{

50
  printf( "ich bin set7\n" );

51
}

52


53
void set8(void)

54
{

55
  printf( "ich bin set8\n" );

56
}

57


58


59


60
// mehrere Zeigertabellen:

61
keyfunction_t key_call[MAXKEYS] =

62
  { &set1,

63
    &set2,

64
    &set3,

65
    &set4,

66
    &set5,

67
    &set6,

68
    &set7,

69
    &set8,

70
  };

71


72
// die jeweils aktuelle Tabelle:

73
keyfunction_t *p_key_call_Konfiguration_aktuell = &key_call[0];

74


75


76
// ruft zur Demo alle Funktionen der aktuellen Tabelle auf

77
void tuwas()

78
{

79
  // Aufruf der 4 Funktionen der aktuellen Tabelle über

80
  // p_key_call_Konfiguration_aktuell, um in das richtige Feld zu

81
  // kommen und darin über Index [0] bis [3]

82
  p_key_call_Konfiguration_aktuell[0]();

83
  p_key_call_Konfiguration_aktuell[1]();

84
  p_key_call_Konfiguration_aktuell[2]();

85
  p_key_call_Konfiguration_aktuell[3]();

86
}

87


88


89
int main( int nargs, char **args )

90
{

91
  // die unteren 4 Elemente benutzen:

92
  printf( "jetzt ist Neumond:\n" );

93
  p_key_call_Konfiguration_aktuell = &key_call[0];

94
  tuwas();

95


96
  // jetzt die oberen 4:

97
  printf( "jetzt ist Vollmond:\n" );

98
  p_key_call_Konfiguration_aktuell = &key_call[4];

99
  tuwas();

100


101
  return 0;

102
}
Antwort Zitieren Bearbeiten Löschen Melden Danke
Thread beobachten

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 17 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.