# Compiler Error bei Funktion Überdeckung von Variable!



## ocsme (7. Sep 2019)

Guten Tag,

irgendwie verstehe ich hier mal wieder etwas nicht 
In Java Funktioniert so etwas:


```
public static int test(int zahl) {
        return zahl*4;
    }
    
    
    public static void main(String[] args) {
        int test = test(4);
        System.out.println(test);
```


wenn ich so etwas in C versuche kommt eine Warunung vom Compiler.

```
int test(int zahl) {
    return 5*zahl;
}

//... in der main das hier:
    int test = test(4);
    printf("%d\n",test);
```

Fehlermeldung:

```
In function ‘main’:
PrimzahlenTest.c:26:13: error: called object ‘test’ is not a function or function pointer
  int test = test(4);
             ^~~~
PrimzahlenTest.c:26:6: note: declared here
  int test = test(4);
```

Verdeckt nun die Variable test die Funktion test? Oder liegt es an etwas anderem?

LG


----------



## Xyz1 (7. Sep 2019)

wech


----------



## Xyz1 (7. Sep 2019)

Oh sorry, ich habe mich vertan...


```
#include <stdio.h>

int
testa (int zahl)
{
  return 5 * zahl;
}

int
main ()
{
  int test = testa (4);
  printf ("%d\n", test);
}
```


geht, aber test nicht. Die Begründung steht hier:









						Can local variables and functions have the same names in C?
					

Suppose I have a single .c file in which I have a local variable a. Can I also have a function in that c file which has the same name a?  EDIT: If not, why?  Conceptually, the local variable is sto...




					stackoverflow.com


----------



## ocsme (7. Sep 2019)

Danke für die schnelle antwort 
Mal wieder stackoverflow.com  ^.^ Da gibt es glaube schon fast alles 

Was mir auch nicht bewusst war es gibt kein Überladen bei C  
Wieso weiß ich nicht und wie man dann Überladen hin bekommt in Java, C++, etc. weiß ich auch noch nicht 

 Da Lernt man Java echt sehr zu schätzen 

LG


----------



## Xyz1 (7. Sep 2019)

ocsme hat gesagt.:


> Mal wieder stackoverflow.com  ^.^ Da gibt es glaube schon fast alles


Wer dort antwortet der ist sicherlich nicht dumm...


----------



## ocsme (7. Sep 2019)

Ich hatte auch gegoolet doch nix gefunden. Mal wieder das Falsche eingeben 

Dumm ist kein Mensch! Doch ich weiß was du meinst 
Da merkt man mal wieder was man noch alles lernen muss!!! Mal gespannt wie es noch weiter geht. Mit den Zeigern kämpfe ich immer noch 

LG


----------



## Xyz1 (7. Sep 2019)

Tröste dich, ich musste auch erst um drei Ecken denken, bevor ich auf den Suchbegriff kam.


----------



## ocsme (7. Sep 2019)

Das ist trotzdem super Deprimierten.
Vor allem vermisst man da echt JAVA  und ich hab erst mit C angefangen.

Was hierbei jetzt noch dazu kommt ist, ich Lerne und Lerne und stopfe hier und da mal so Löscher von meinen Fragen doch es werden nicht WENIGER eher MEHR!!! 

Bei Java hat mir das ganze später ja so weit wie ich gekommen bin Sinn gemacht, doch dabei habe ich mich ja nie mit dem tiefen beschäftigt  Also wie Funktioniert die JVM, wie Funktioniert so ein Compiler, etc.
Nun Frage ich mich das alles erneut und bekomme nur noch mehr Fragezeichen in meinem Kopf. Das alles "irgendwie" aufeinander Aufbaut sollte jedem Klar sein  Doch wie  Ich weiß auch das so etwas eigentlich nicht "mehr so wichtig!" ist wie es Funktioniert. Das wäre das selbe wie wenn man Mathematik oder Physik Studieren geht und alles beweisen muss/will um es zu verstehen obwohl die beweise schon da sind und man weis das es so geht! grrrr..... Gehirnabsturz 

naja mal schauen wie es weiter geht.
Das Thema hat mich definitiv wieder mehr Verwirrt als alles andere  

Danke für die nette Hilfe 

LG


----------



## M.L. (8. Sep 2019)

> Mathematik oder Physik Studieren geht und alles beweisen muss/will um es zu verstehen obwohl die beweise schon da sind und man weis das es so geht!


  Allerdings wird man in diesen Studiengängen auch stärker darauf getrimmt die formellen Voraussetzungen dieser oder jener Gesetze / Werkzeuge / Verfahren / ... zu beachten und zu befolgen.  Um beim obigen Beispiel zu bleiben: der Python 3.7 Interpreter hat weniger Probleme mit gleichlautenden Variablen und Funktionsnamen.

```
def test(zahl):
  return zahl*5

test = test(4)
print(test)
```
   Ergebnis auf der Kommandozeile: 20
Nebenbei hat auch der VC++ Compiler mit dem oben genannten C-Code sein Problem.


----------



## Xyz1 (8. Sep 2019)

Nebenbei sei angemerkt, in Assembler sieht Dein Programm so aus:

```
testa:
.LFB0:
	pushq	%rbp
	movq	%rsp, %rbp
	movl	%edi, -4(%rbp)
	movl	-4(%rbp), %edx
	movl	%edx, %eax
	sall	$2, %eax
	addl	%edx, %eax
	popq	%rbp
	ret
.LFE0:
	.size	testa, .-testa
	.section	.rodata
.LC0:
	.string	"%d\n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB1:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp
	movl	$4, %edi
	call	testa
	movl	%eax, -4(%rbp)
	movl	-4(%rbp), %eax
	movl	%eax, %esi
	leaq	.LC0(%rip), %rdi
	movl	$0, %eax
	call	printf@PLT
	movl	$0, %eax
	leave
	ret
```

Es gibt zwar das Funktionslabel testa, aber der lokale Variablenname test taucht nicht mehr auf - demzufolge ist es einfach eine Beschränkung des C Compilers.


----------



## mihe7 (8. Sep 2019)

ocsme hat gesagt.:


> Was mir auch nicht bewusst war es gibt kein Überladen bei C
> Wieso weiß ich nicht


Ich habe in ähnlicher Angelegenheit schon mal was dazu geschrieben: Du musst C mit völlig anderen Augen sehen als Java. Die Ursprünge reichen bis in die 60er-Jahre zurück. Du kannst die Zeit damals nicht mit Mitte der 90er vergleichen. C wurde für die Weiterentwicklung von Unix "erfunden", so dass Unix eines der ersten Betriebssysteme war, das nicht in Assembler geschrieben wurde bzw. werden musste. Für so "Unfug" wie Überladen etc. war RAM und Laufzeit (z. B. für den Compiler) viel zu wertvoll (wenn ich mich recht entsinne war Ende der 80er eine 128 KB RAM-Erweiterung für etwa 200 DM - nach heutigen Maßstäben etwa 160-180 € - zu haben).  Das ist nur meine persönlich Meinung.



ocsme hat gesagt.:


> wie man dann Überladen hin bekommt in Java, C++, etc. weiß ich auch noch nicht


Kombiniere die Bezeichner der Methode/Funktion mit Parametertypen. Dann ist A(int) etwas anderes als ein A(String) oder ein A(int, int) usw.


----------



## ocsme (16. Sep 2019)

Sry für die späte Nachricht hier, ich hatte leider einiges um die Ohren 

Danke an euch drei @M.L. , @Tobias-nrw und @mihe7 
Ich glaube so langsam verstehe ich etwas mehr 

Eine Frage hätte ich noch wie bekommt man den C Code in Assembler umgewandelt den @Tobias-nrw hat das Programm sicherlich nicht in Assembler geschrieben oder etwa doch?
Man kann sich Java Code ja auch in Assembler ausgeben lassen  thx @mihe7 dazu hatte ich damals ja auch einige Fragen die von die geklärt werden konnten soweit ich mich entsinnen kann


----------



## Xyz1 (16. Sep 2019)

Also ganz allgemein... noch ohne Spezialoptionen...
Du hast eine main.c Datei und den gcc.
Dann: gcc -O0 -S main.c -o main1.S

main1.S kannst du mit einem Editor ansehen/verändern.

Übersetzen: gcc main1.S -o deineDatei.endung


----------



## Xyz1 (16. Sep 2019)

Achso und wichtig ist, im letzten Schritt die dynamischen libraries zu linken mit -l...


----------



## ocsme (16. Sep 2019)

Das ist ja mal nett 
Wenn man jetzt noch etwas mehr Assembler verstehen würde dann ist es sicherlich auch Hilfreich 
Denn ich sehe auch zum ersten mal das ein String im Assembler-Code enthalten sein kann also ähnlich wie im C - Code das kenne ich auch nicht 
Naja ich bleibe erst mal bei Java und C/C++  und übe fleißig weiter.

LG


----------



## Xyz1 (16. Sep 2019)

Wenn dir gerade lwl ist so compiliere das mal:

```
.file	"ab.c"
	.text
	.globl	testa
	.def	testa;	.scl	2;	.type	32;	.endef
	.seh_proc	testa
testa:
	pushq	%rbp
	movq	%rsp, %rbp
	pushq	%r12
	subq	$32, %rsp

	movq		$5, %r12
	cvtsi2sd	%r12, %xmm0
	cvtsi2sd	%ecx, %xmm1
	mulsd		%xmm0, %xmm1
	cvtsd2si	%xmm1, %eax

	addq	$32, %rsp
	popq	%r12
	popq	%rbp
	ret
	.seh_endproc

	.def	__main;	.scl	2;	.type	32;	.endef
	.section .rdata,"dr"
.LC0:
	.ascii "%d\12\0"
	.text
	.globl	main
	.def	main;	.scl	2;	.type	32;	.endef
	.seh_proc	main
main:
	pushq	%rbp
	movq	%rsp, %rbp	
	subq	$48, %rsp	

	call	__main	

	movl	$4, %ecx
	call	testa	 
	movl	%eax, %edx
	leaq	.LC0(%rip), %rcx
	call	printf

	movl	$0, %eax

	addq	$48, %rsp	
	popq	%rbp	 
	ret
	.seh_endproc
	.ident	"GCC: (GNU) 7.4.0"
```


Die Action passiert in Zeile 12-16 und in Zeile 39 bis 43.


----------



## ocsme (16. Sep 2019)

*geht nicht kommt das da:
*


> avr-gcc test.S -o test
> ab.c: Assembler messages:
> ab.c:4: Error: unknown pseudo-op: `.def'
> ab.c:5: Error: unknown pseudo-op: `.seh_proc'
> ...




weder mit *avr-gcc* noch mit* gcc *klappt es :/

LG


----------



## Xyz1 (16. Sep 2019)

Oh, 32-bit ?


----------



## ocsme (16. Sep 2019)

nein eigentlich nicht 64-bit


----------



## Xyz1 (16. Sep 2019)

ruf mal Bitte gcc --version auf


----------



## ocsme (16. Sep 2019)

gcc (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


----------



## Xyz1 (16. Sep 2019)

Das müsste klappen:

```
.file	"ab.c"
	.text
	.globl	testa
testa:
	pushq	%rbp
	movq	%rsp, %rbp
	pushq	%r12
	subq	$32, %rsp

	movq		$5, %r12
	cvtsi2sd	%r12, %xmm0
	cvtsi2sd	%ecx, %xmm1
	mulsd		%xmm0, %xmm1
	cvtsd2si	%xmm1, %eax

	addq	$32, %rsp
	popq	%r12
	popq	%rbp
	ret

.LC0:
	.string "%d\12\0"
	.text
	.globl	main
	.type	main, @function
main:
	pushq	%rbp
	movq	%rsp, %rbp		

	movl	$4, %ecx
	call	testa	 
	movl	%eax, %esi
	leaq	.LC0(%rip), %rdi
	call	printf

	movl	$0, %eax
	
	popq	%rbp	 
	ret
	.ident	"GCC: (GNU) 7.4.0"
```


Aufruf:
`x86_64-linux-gnu-gcc ab.S`


----------



## ocsme (16. Sep 2019)

Kompilieren geht nun doch beim ausführen mit ./a.out kommt
./a.out: Symbol `printf' causes overflow in R_X86_64_PC32 relocation
Speicherzugriffsfehler (Speicherabzug geschrieben)

lassen wir das besser an dieser Stelle


----------



## Xyz1 (16. Sep 2019)

Oh sorry, das liegt irgendwie an dem `printf` Aufruf... Aber kann ich so aus der Ferne nicht diagnostizieren


----------



## Xyz1 (16. Sep 2019)

Alternative wär, eine main Funktion (mit `printf("%d\n", 10);` zum Beispiel) einmal mit `x86_64-linux-gnu-gcc -S ab.c -o ab1.S` zu übersetzen und dann den main Teil in der `ab.S` anzupassen und zu ersetzen...


----------



## mihe7 (17. Sep 2019)

ocsme hat gesagt.:


> Wenn man jetzt noch etwas mehr Assembler verstehen würde dann ist es sicherlich auch Hilfreich
> Denn ich sehe auch zum ersten mal das ein String im Assembler-Code enthalten sein kann also ähnlich wie im C - Code das kenne ich auch nicht


Auch hier bietet es sich an, die Sache von der anderen Seite zu betrachten. 

Was brauchst Du, um ein Programm für eine CPU zu schreiben? Mindestens mal die Befehle des Prozessors mit den Opcodes. Nehmen wir mal was einfaches, einen 8-Bit-Mikrocontroller und weil Du avr-gcc erwähnt hast, nehmen wir mal einen AVR an.

Der Prozessor kennt bestimmte Befehle, beim AVR sind diese immer 16-Bit breit (http://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf). Um den Prozessor einen Taktzyklus warten zu lassen, kannst Du den Befehl 0x0000 verwenden. Willst Du das Register R2 auf 0 setzen, kannst Du das mit einem exklusiven OR machen, das wäre der Befehl 0x2422.

Das fertige Programm ist nichts anderes als eine Folge von Bytes. Der Prozessor verfügt über einen Befehlszeiger (beim AVR program counter, PC, genannt), der auf die Adresse des nächsten zu verarbeitenden Befehls zeigt. Die Abarbeitung verändert den PC. In der Regel wird er einfach auf den folgenden Befehl gestellt, es gibt aber auch Befehle, die direkt Einfluss auf den Zeiger nehmen wie z. B. Sprünge, Aufrufe von Unterfunktionen.

Da das Programm nur eine Bytefolge ist, kannst Du auch Daten darin unterbringen. Du musst nur darauf achten, dass der Prozessor nicht die Daten als Befehle verarbeitet (d. h. der PC darf nicht dorthin kommen, wo die Datenbytes stehen). Umgekehrt: ob ein Byte im Programm ein Datum oder ein Befehl ist, hängt einfach davon ab, ob es vom Prozessor als Befehl verarbeitet wird oder nicht.

Du könntest durchaus so programmieren, das wäre aber sehr aufwändig und fehleranfällig. Daher verwendet man einen Assembler, der in seiner einfachsten Form die Befehle einfach in Opcodes übersetzt und eine Folge von Bytes rausschreibt. Die zwei Befehle oben wären in Assembler `nop` und `eor r2, r2`. Das würde dann zu 0x0000 bzw. 0x2422 übersetzt und jeweils in Form zweier Byte rausgeschrieben. 

Um Daten anzugeben, könntest Du z. B. einfach Bytes anhängen. Da du weißt, wie lange Dein Programm ist, kennst Du dann auch die Adresse der Daten und kannst dann im Programm darauf zugreifen. Der Assembler unterstützt Dich auch hier, so gibt es beim AVR-Assembler (nicht gcc) die Direktive `.db`, um Byte-Konstanten im Programmspeicher zu definieren (beim gcc-avr wäre das `.byte`). Dort (bzw. beim gcc mit `.string`) kannst Du eben auch Zeichenketten angeben, die beim Übersetzen eben in eine Bytefolge ... übersetzt werden. Außerdem kennen die Assembler auch Labels, so dass die Adressen für Dich automatisch berechnet werden.


----------



## Xyz1 (17. Sep 2019)

Tobias-nrw hat gesagt.:


> x86_64-linux-gnu-gcc -S ab.c -o ab1.S


Kannst Du das einmal aufrufen und die Ausgabe hier posten? Das würde mich interessieren


----------



## mrBrown (17. Sep 2019)

ocsme hat gesagt.:


> Eine Frage hätte ich noch wie bekommt man den C Code in Assembler umgewandelt den @Tobias-nrw hat das Programm sicherlich nicht in Assembler geschrieben oder etwa doch?


Alternativ zum selber kompilieren: https://godbolt.org


----------



## Xyz1 (17. Sep 2019)

mrBrown hat gesagt.:


> Alternativ zum selber kompilieren


Oder so... Aber es soll ja auch (garantiert) auf @ocsme s "Maschine" fehlerfrei laufen.


----------



## ocsme (18. Sep 2019)

was soll ich jetzt wie übersetzen und wie soll die datei heißen?
Sry ich stehe hier nur noch auf dem Schlauch dieses verkackte C regt mich nur noch auf!


----------



## Xyz1 (18. Sep 2019)

Mich regt es auch schon auf... Das ist ja jetzt auch nicht so wichtig.


----------



## mihe7 (18. Sep 2019)

ocsme hat gesagt.:


> Sry ich stehe hier nur noch auf dem Schlauch dieses verkackte C regt mich nur noch auf!


Das hat hier aber schon lange nichts mehr mit C zu tun  

Geh einfach her, schreib ein C-Programm (test.c):

```
#include<stdio.h>

int main(int argc, char *argv[]) {
    printf("Hello World!");
}
```
Dieses kannst Du mit 

```
gcc -S test.c
```
in Assembler-Code übersetzen lassen. Die Datei heißt dann test.s.

Dort kannst Du Dir dann ansehen, wie das Programm eben in Assembler aussieht.

Du kannst diese Datei auch verwende, um das fertige Programm zu erstellen, dazu einfach

```
gcc test.s
```
ausführen, um Deine a.out zu erhalten. Das ist alles.


----------



## Xyz1 (18. Sep 2019)

@mihe7 Das ist nicht ganz das was ich wollte... Es ging ja darum, mein unterschriebenes Assembler auch bei ihm laufbar zu machen (und das geht mit einem entsprechenden Aufruf in der Main sowie dem richtigen Compiler)... Aber da habe ich jetzt auch keinen Nerv zu


----------



## M.L. (19. Sep 2019)

> C regt mich nur noch auf!


 Das Konstrukt aus dem Startposting dürfte kein C-Problem (oder 'nur' ein Problem bei Programmiersprachen, die das Pointer-/Delegaten-/... Konzept kennen) sein: im Selbsttest gab es mit C++, C#, Node.js und JavaScript eine Fehlermeldung (im Ggs. zu PHP, Python, Java)

```
function test(zahl) {
    return zahl * 4;
}
let test = test(4);
console.log('Ergebnis :', test);
```
   (Fehlermeldung: Identifier 'test' has already been declared)


----------



## ocsme (19. Sep 2019)

Darum ging es am Anfang von dem Thema hier auch.
Dann ist es etwas ausgeufert 
Doch ich hätte jetzt mal abgesehen von dem Compilier Problem hier im Theama noch ein Problem mit diesem Code:


```
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
#define countof(a) (sizeof(a)/sizeof(a[0]))

typedef struct Mitgliederdatei{
    char name[64];
    int nr;
    int status;
    double gebuehr;
    int anzahl;
} data;

data *eingabe() {
    data *a = (data *) malloc(sizeof(data));
    
    if(a == NULL) {
        printf("Konnte keinen Speicher reservieren!\n");
        exit(EXIT_FAILURE);
    }

    printf("Name: ");
    fgets(a->name, 64, stdin);
   // scanf("%s",a->name);
    while(getchar() != '\n');
    
    printf("Mitgliedernummer: ");
    do {
        scanf("%7d",&a->nr);
    } while(getchar()!= '\n');
    printf("Status: ");
    do {
        scanf("%d",&a->status);
    } while(getchar()!= '\n');
    printf("Gebuehren: ");
    do {
        scanf("%lf",&a->gebuehr);
    } while(getchar()!= '\n');
    printf("Anzahl: ");
    do {
        scanf("%d",&a->anzahl);   
    } while(getchar()!= '\n');
    
    return a;
}

void ausgabe(data **a, int n) {
    int i;
    
 for(i = 0; i < n; i++) {
        printf("\nAusgabe fuer Element %d:\n", i);
        printf("Name: %s\n", (*(a + i))->name);
        printf("Mitgliedsnummer: %d\n", (*(a + i))->nr);
        printf("Status: %d\n", (*(a + i))->status);
        printf("Gebuehren: %lf\n", (*(a + i))->gebuehr);
        printf("Anzahl: %d\n", (*(a + i))->anzahl);
    }
}

int main(void) {
    
    int auswahl, n;
    int count = 0;
    printf("Wieviele Plaetze soll das Array haben: ");
    scanf("%d",&n);
    
    data **mitglieder;
    mitglieder = (data **) malloc(n * sizeof(data*));
    
    if(mitglieder == NULL)
        printf("Fehler");
        
   do {
      printf("-1- Neue Eingabe\n");
      printf("-2- ---\n");
      printf("-3- Alle Adressen ausgeben\n");
      printf("-4- ---\n");
      printf("-5- Programm beenden\n");
      printf("\nIhre Auswahl : ");
      scanf("%d",&auswahl);

      switch(auswahl) {
         case 1 : mitglieder[count] = eingabe();
                  count++;
                  break;
         case 2 :
                  break;
         case 3 : ausgabe(mitglieder,count);
                  break;
         case 4 :
                  break;
         case 5 : printf("Ende....\n");
                  break;
         default: printf("Falsche Eingabe\n");
      }
   }while(auswahl <5);
   return EXIT_SUCCESS;

}
```


Das zu compilieren funktioniert. Problem ist bei der eingabe das fgets. Hier kann ich einen String übergeben der aber nicht in meiner Structur Variable gespeichert wird. Wieso weiß ich einfach nicht
Die anderen ganze Variablen funktionieren nur der String nicht.
Wenn ich es mit scanf mache klappt es! Doch dabei kann ich ja kein Leerzeichen nutzen eben für einen Namen. Ich könnte dann max. Vorname und Nachname einrichten. Doch es sollte auch so klappen oder sehe ich das falsch 

LG


----------



## mihe7 (19. Sep 2019)

ocsme hat gesagt.:


> Wieso weiß ich einfach nicht


Das Problem ist nicht das fgets sondern das scanf in main() -> \n ist noch im Puffer und daher liefert fgets() dieses.


----------



## ocsme (19. Sep 2019)

Heißt das man soll nach jedem scanf den Puffer leer machen mit fflush(stdin)?

Doch leider verstehe ich das auch nicht. Hab versucht damit den Puffer leer zu machen doch es geht immer noch nicht 

Das Verhalten von fflush() ist für stdin nicht definiert.
Unter Linux leert es nicht den Eingabepuffer.
mhhh... ich bin überfordert gerade  wie bekomme ich dieses doofe "\n" aus dem Puffer...

LG


----------



## ocsme (19. Sep 2019)

so ich hab das problem gelöst in dem ich vorher:
`char c = getchar();`
aufgerufen habe und damit den Puffer leer gemacht habe bzw. das Zeichen "\n" der Variable c zugewiesen habe.

Verstehe ich das nun richtig das mit der Funktion getchar() der lese puffer angezeigt werden kann?

In der Ausgabe hat er mir dann immer noch 2 Leerzeichen gesetzt da muss man dann hinter dem String bei der Ausgabe das \n weg machen da im String das \n zeichen ja schon mit drin ist.
Sieht nun so aus:


```
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
#define countof(a) (sizeof(a)/sizeof(a[0]))

typedef struct Mitgliederdatei{
    char name[64];
    int nr;
    int status;
    double gebuehr;
    int anzahl;
} data;

data *eingabe() {
    data *a = (data *) malloc(sizeof(data));
    
    if(a == NULL) {
        printf("Konnte keinen Speicher reservieren!\n");
        exit(EXIT_FAILURE);
    }
    char c = getchar();
    printf("Name: ");
    fgets(a->name, 64, stdin);
   // scanf("%s",a->name);
    
    
    printf("Mitgliedernummer: ");
    do {
        scanf("%7d",&a->nr);
    } while(getchar()!= '\n');
    printf("Status: ");
    do {
        scanf("%d",&a->status);
    } while(getchar()!= '\n');
    printf("Gebuehren: ");
    do {
        scanf("%lf",&a->gebuehr);
    } while(getchar()!= '\n');
    printf("Anzahl: ");
    do {
        scanf("%d",&a->anzahl);   
    } while(getchar()!= '\n');
    
    return a;
}

void ausgabe(data **a, int n) {
    int i;
    
 for(i = 0; i < n; i++) {
        printf("\nAusgabe fuer Element %d:\n", i);
        printf("Name: %s", (*(a + i))->name);
        printf("Mitgliedsnummer: %d\n", (*(a + i))->nr);
        printf("Status: %d\n", (*(a + i))->status);
        printf("Gebuehren: %lf\n", (*(a + i))->gebuehr);
        printf("Anzahl: %d\n", (*(a + i))->anzahl);
    }
}

int main(void) {
    
    int auswahl, n;
    int count = 0;
    printf("Wieviele Plaetze soll das Array haben: ");
    scanf("%d",&n);

    data **mitglieder;
    mitglieder = (data **) malloc(n * sizeof(data*));
    
    if(mitglieder == NULL)
        printf("Fehler");
        
   do {
      printf("-1- Neue Eingabe\n");
      printf("-2- ---\n");
      printf("-3- Alle Adressen ausgeben\n");
      printf("-4- ---\n");
      printf("-5- Programm beenden\n");
      printf("\nIhre Auswahl : ");
      scanf(" %d",&auswahl);

      switch(auswahl) {
         case 1 : mitglieder[count] = eingabe();
                  count++;
                  break;
         case 2 :
                  break;
         case 3 : ausgabe(mitglieder,count);
                  break;
         case 4 :
                  break;
         case 5 : printf("Ende....\n");
                  break;
         default: printf("Falsche Eingabe\n");
      }
   }while(auswahl <5);
   return EXIT_SUCCESS;

}
```

Also bringt das alles nix dann muss ich mir hier auch erst einmal die Methoden die es in C schon gibt einmal genauer anschauen 
Sonst macht man irgendwas und es kommen laufend solche kleine Fehler zu Stande 

Danke trotzdem mal wieder


----------

