Compiler Error bei Funktion Überdeckung von Variable!

[ocsme]

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]

wech

 

[Xyz1]

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]

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]

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

Wer dort antwortet der ist sicherlich nicht dumm...

 

[ocsme]

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]

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

 

[ocsme]

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.]

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]

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]

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.

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]

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]

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]

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

 

[ocsme]

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]

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]

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'
ab.c:7: Error: Unbekannter Befehlscode »pushq«
ab.c:8: Error: Unbekannter Befehlscode »movq«
ab.c:9: Error: Unbekannter Befehlscode »pushq«
ab.c:10: Error: Unbekannter Befehlscode »subq«
ab.c:10: Error: junk at end of line, first unrecognized character is `3'
ab.c:12: Error: Unbekannter Befehlscode »movq«
ab.c:12: Error: junk at end of line, first unrecognized character is `5'
ab.c:13: Error: Unbekannter Befehlscode »cvtsi2sd«
ab.c:14: Error: Unbekannter Befehlscode »cvtsi2sd«
ab.c:15: Error: Unbekannter Befehlscode »mulsd«
ab.c:16: Error: Unbekannter Befehlscode »cvtsd2si«
ab.c:18: Error: Unbekannter Befehlscode »addq«
ab.c:18: Error: junk at end of line, first unrecognized character is `3'
ab.c:19: Error: Unbekannter Befehlscode »popq«
ab.c:20: Error: Unbekannter Befehlscode »popq«
ab.c:22: Error: unknown pseudo-op: `.seh_endproc'
ab.c:24: Error: unknown pseudo-op: `.def'
ab.c:25: Fatal error: unrecognized .section attribute: want a,e,w,x,M,S,G,T

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

LG

 

[Xyz1]

Oh, 32-bit ?

 

[ocsme]

nein eigentlich nicht 64-bit

 

[Xyz1]

ruf mal Bitte gcc --version auf

 

[ocsme]

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]

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]

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]

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

 

[Xyz1]

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]

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]

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]

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]

Alternativ zum selber kompilieren

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

 

[ocsme]

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]

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

 

[mihe7]

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]

@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.]

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]

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]

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]

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]

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