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.
a geht nicht zur laufzeit, ist einfach so.
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.
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.
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.
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 | }
|
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.