Forum: C-Programmieren

Hallo...

Ich habe folgendes Problem:

Ich will/soll/werde/muss ein C programm erstellen welches im wesentlichen eigentlich nur bubblesort bewerkstelligen soll...

Allerdings gibts da ein paar Dinge mit denen ich mich sehr schwer tue...

Das Programm muss mit verschiedenen Dateitypen (int,double etc.) arbeiten können...allerdings soll der ent. Speicher für die zu sortierende Liste per malloc beschafft werden...

Genau hier will es nicht klappen :(...entweder hasst mich malloc,mein compler,ANSI C oder ich steh wirklich boese aufm schlauch...

Vielleicht wäre jmd so nett mir ein Beispiel zu posten,wie ich bei einem string per malloc speicher fuer ent. Dateitypen allokiere...

Ich hab auch im OpenBook nachgsehen und K+R gewaelzt...aber irgendwie hat mich das alles nicht weitergebracht :-/

Ich poste mal als Anhang meinen bisherigen Code...allerdings
kann der nur als Orientierung dienen da ich den mittlerweile derart oft umgeschrieben,geloescht etc. habe, das ich ihn eh von grund auf neu schreiben muss (am schluss hab ich schon fast zufallsmaessig an malloc rumprobiert...)

#include <stdlib.h>
#include <stdio.h>



main()
{
int *liste;		/* Zeiger auf 1. Element im Datenvektor */
int n,l;			/* Anzahl und Länge der Datenobjekte */
extern int vgl();  /* Vergleichsfunktion */
int choice;
int counter;

/**** Datenerfassung****/
eingabe(&liste, &n, &l,&choice);

/****Sortierung****/
//if(n > 1)
//qsort(liste,n,l,vgl);

/****Ausgabe****/
ausgabe(liste, n,l,choice);
}

eingabe(int *liste,int n,int l,int choice)
{
choice=0;

puts("Bitte einen ent. Dateityp auswaehlen\n");
puts("1 für Int,2 für double\n\n");
scanf("%d",&choice);
puts("\n\n");

switch(choice)
	{
		case 1:
			*liste=(int *)malloc(10*sizeof(int));
			liste[0]='5';
			liste[1]='6';
			liste[2]='7';
			liste[3]='8';
			liste[4]='9';
			liste[5]='10';
			liste[6]='1';
			liste[7]='2';
			liste[8]='3';
			liste[9]='4';
			puts("Liste wird automatisch mit 10 Int Werten gefuellt"); 
			break;
			
		case 2:
			*liste=(int *)malloc(10*sizeof(double));
			liste[0]='5';
			liste[1]='6';
			liste[2]='7';
			liste[3]='8';
			liste[4]='9';
			liste[5]='10';
			liste[6]='1';
			liste[7]='2';
			liste[8]='3';
			liste[9]='4';
			puts("Liste wird automatisch mit 10 double Werten gefuellt"); 
			break;
			

		default: puts("Falsche Eingabe! Programm wird beendet");
//				exit();
					

	}
	
}

ausgabe(int *liste,int n,int l,int choice,int counter)
{
	puts("Ausgabe der Liste\n\n");

	switch(choice)
		{
		case 1:
				puts("Ausgabe der sortierten int Werte\n");
				break;

		case 2:
					puts("Ausgabe der sortierten double Werte\n");
					break;
		}
counter=0;
	for(counter;counter<=9;counter++)
	{
		printf("%c\n",&liste[counter]);
	}
}

Danke schonmal...


yours
ara

 

Hier ist der ein oder andere grundlegende Fehler enthalten.

Exkurs Zeiger:
Jede Variable hat eine Adresse. Die Adresse gibt an, wo die Variable im RAM abgelegt ist.
Ein Zeiger ist dazu da, diese Adresse zu speichern. Da ein Zeiger also etwas speichert, verbraucht er selbst natürlich auch Speicher. Folglich hat er selbst auch eine Adresse. Was uns aber erstmal interessiert ist, das ein Zeiger auf einen Wert in dem Speicher zeigt.
Der Zeiger selber weiß nun aber nicht, wieviel Byte der Wert auf den er zeigt, denn nun belegt. Das muss also noch zusätzlich angegeben werden. Das macht man über den Datentyp.

--> int *liste;/* Zeiger auf 1. Element im Datenvektor */

In diesem Falle also die größe eines Integers. Allerdings war die Vorgabe ja, das es auch für Double gehen soll. Und Double ist (meistens zumindest) größer als int und muss zudem noch anders behandelt werden. Deshalb kannst du dich hier schonmal nicht konkret auf einen der beiden Typen festlegen.

>> *liste=(int *)malloc(10*sizeof(double));

1. zu *liste:
malloc allokiert Speicher und gibt die Adresse zurück, an welchem Ort er das gemacht hat. Für Adressen sind Zeiger zuständig. *liste wäre durch das * dereferenziert, heißt, man würde auf den Inhalt der im Zeiger gespeicherten Adresse zugreifen, nicht auf den Adress_wert_, den der Zeiger speichert.
Mal ein kurzes Beispiel zur besseren Verdeutlichung:
int *wert; //in wert kann man jetzt Adressen speichern
wert=(int *)malloc(sizeof(int)); //hier wird jetzt also Speicher reserviert, und die Adresse davon wird in wert gespeichert
//um einen konkreten Wert in wert zu speichern, müssen wir sie dereferenzieren
*wert= 4;

2. zu malloc
Der Rückgabetyp von malloc ist void *. Indem man die Funktion castet (kann man das so sagen..?) kann man sich einen Zeiger auf jeden beliebigen Datentyp zurückgeben lassen.
In diesem Falle würdest du also einen Zeiger auf ein Array von Integern zurückgeben lassen. Was du aber allokierst ist ein Array von Doubles. Das passt nicht zusammen - was du letztenendes verwenden kannst beschränkt sich auf int.

>>liste[0]='5';

Das ist zwar erlaubt, ist aber glaube ich nicht das was du haben möchtest. Wenn du etwas in '' schreibst, wird angenommen das du ein Char übergibst. Chars sind 1 Byte groß und sie haben auch einen entsprechenden Zahlenwert (für weitere Informationen -> suche nach ASCII), aber '5' != 5.
Wenn du einen Zahlenwert (int, double, float, etc.) speichern möchtest, schreibe einfach die Zahl hin, ohne "" oder ''.

liste[0]= 5; //und gut ist

Ich hoffe dir etwas geholfen zu haben.
Als Lösungsvorschlag für das Problem mit den Ints und Doubles würde ich dir das Kapitel über Unions empfehlen, ob das die beste/eleganteste Lösung ist kann ich allerdings nicht versprechen.

Viel Erfolg noch

 

aradriel
*********

tut mir leid dir das sagen zu müssen aber dein code ist grauenvoll und ziemlich falsch
was sollen diese seltsame kommentare wie *****datenerfassung****, kannst du dir dein eigenes Programm nicht merken? Was eine Funktion tut, schreibt man über sie drüber wo man sie definiert hat und nur wenn etwas total nich klar ist, sollte man ordentliche Kommentate schreiben.
Desweiteren, schon mal was von for-Schleifen und einer Zufallsinitialisierung des Feldes gehört? Malloc wird nicht gecastet.
Dieser Funktionsaufruf eingabe(&liste, &n, &l,&choice); entspricht in keinster Weise dieser eingabe(int *liste,int n,int l,int choice) Defintion.

Was soll das?
*liste=(int *)malloc(10*sizeof(int));
Schon mal genauer drüber nachgedacht was du da tust?

*liste=(int *)malloc(10*sizeof(double));
Genauso schlimm. Gehirn einschalten.

//exit();

Noch nie mit exit codes gearbeitet? Da würde ein Wert fehlen.

>counter=0;
>for(counter;counter<=9;counter++)

Was soll das? Keine Ahnung von for schleifen?

>printf("%c\n",&liste[counter]);

was ist das denn...

Das andere Zeugs hat unreale socke ja schon angemängelt.

Ich geb dir einen wertvollen Tipp, Code komplett löschen und neu schreiben, ach ja und das Gehirn dabei einschalten.

bye

imi

 

Hallo!
Du dynamische Speicherallokierung ist bei dir falsch
*liste=(int *)malloc(10*sizeof(int));

" *liste"

Darum geht es , einen Bereich im Speicher zu reservien.
D.h. die Adresse.
Aber mit "*list" handelt es sich um den Inhalt der Adresse und nicht die Adresse . Deshalb mekert dein Compiler.
so wäre richtig liste=(int *)malloc(10*sizeof(int));
da die liste ist , wie du deklariert hast , ein Zeiger von Typ int und nicht ein Zeiger auf einen Zeiger von Typ int.
Außerdem wenn du Speicherplatz für String dynamisch anlegen möchtest, mußt du so machen

liste=(char *)malloc(10*sizeof(char)+1);
"+1" ist für '\0'



Viel glück!!!
Walace

 

noch mal...malloc wird nicht gecastet und das ist nicht sein einziges problem ich hab noch genug andere aufgezählt

bye

imi