konsti4u

Nicht jeder kennt sich überall so gut aus, vll wäre es nicht schlecht, die Lösung zu posten, falls mal später jemand das gleiche Problem :-)

Eine andere Möglichkeit für das alles wäre, Shiften...

Damit kann man rauszufinden ob x an der n. Stelle eine 0 oder 1

(x >> n) & 1

Code-Tags macht man mit [ code ] Hier der Quelltext [ /code ] (ohne Leerzeichen in den eckigen Klammern)

printf("\nDer von ihnen eingegebene Dollar Betrag %.2f entspricht %2.f Euro.",dollar,USDollarZuEuro(USDollar));

du übergibst hier der Methode USDollarZuEuro(...) die Variable USDollar, die du gar nicht deklariert hast, du musst hier dollar übergeben.

MfG

Ach zerstören ist heutzutage das kleinere übel, es gibt Reverse Connection Trojaner, Password-Stealer, Reverse-Proxy uvm., plötzlich sollst du auf einmal irg.welche usenet Accounts gekauft und irg.welche Gigabit-Server gemietet haben, dein Rapidshare-Account ist weg, sowie haste bei Ebay grad irg.welche Laptops gekauft... jaja, sowas passiert wenn man ein lustiges Programm eines 14 jährigen testet...

Je nach Vorhaben, wenn du nichts genaues vor hast, dann nimm eine "einfache" Sprache, wo du viele Bücher und Hilfe im Netz findest und mit der du schnell Erfolge haben kannst, so dass es nicht langweilig wird.

Ich würde empfehlen: Delphi, C++, oder C#/VB.net. Im Prinzip ist es nicht wirklich wichtig welche Sprache um das "Programmieren" an sich zu lernen. Jede Sprache hat natürlich ihre besonderen Eigenschaften, ich denke Anfangs sind die oben angeführten Sprachen am besten geeignet.

Verstehe nicht, wie man einfach so fremde Dateien öffnet... verlasst ihr euch wirklich so sehr auf euren Anti-Virus/Firewall, oder seid ihr gutgläubig?^^

Also wäre ich Administrator, würde ich es verbieten ausführbare Dateien zu posten ohne Sourcecode...

Kopfgesteuert (abweisende Schleife):

int i, summe;

summe=0;

i=0;

while(i < 10) {

    summe= summe + i;

    i++;

}

Fußgesteuerte Schleife (nicht abweisende Schleife):

int i, summe;

summe=0;

i=0;

do {

    summe = summe + i;

    i ++;

} while (i <10);

Beide Schleifen machen das gleiche, wo liegt der Unterschied, ganz einfach wie oben schon gesagt, die Fußschleife läuft mindestens einmal durch, das kann man nicht verhindern. So würde z.B. der folgende Schleifenrumpf kein einziges Mal durchlaufen, denn diese prüft erst die Bedingung und falls diese zutrifft wird der Schleifenrumpf ausgeführt, bei der Fußgesteuerten dagegen wird der Rumpf mind. einmal durchlaufen, weil diese zuerst die Anweisungen im Schleifenrumpf ausführt und dann erst testet, ob die Bedingung erfüllt ist!

int i, summe;

summe = 0;

i =1000;   //beachte hier die Änderung

while(i < 10) {

    summe = summe + i;

    i ++;

}

Wird keinmal durchlaufen! Summe am Ende 0; i am Ende 1000;

int i, summe;

summe =0;

i=1000;

do {

    summe = summe + i;

    i ++;

} while (i <10);

Wird einmal durchlaufen (summe am ende = 1000), i am Ende 1001;

Das mit dem mind. einmal durchlaufen kenne ich unter "nicht abweisende"-Schleife:

https://www.tu-chemnitz.de/wirtschaft/wi1/lehre/2002_ws/wi_pr1/prog03.htm

Kopf- und Fußgesteuert... sollte wohl das gleiche sein, die Schleifenbedingung wird dabei wohl vor dem Schleifenrumpf (kopfgesteuert) oder nach dem Schleifenrumpf (fußgesteuert) geprüft

Naja, du müsstest denke ich einen algorithmus schreiben, welcher zu jedem Datum (Kalenderwoche) den Wochentag berechnet und von diesem aus, wenn du z.b weißt es war ein Mittwoch, 2 Tage zurückgehst, wobei du dann natürlich wenn du "0" erreichst den Monat um eins verringerst und mit dem entsprechendem Maximaldatum des Vormonats fortfährst, ebenso wenn du nach vorne schaust und das Maximaldatum des zu prüfenden Monats überschreitest... Gibt halt einige Sonderfälle...

Das wäre meine intuitive Lösung, wie viele Tage ein Monat hat ist leicht über den gregorianischen Kalender zu errechnen

Zur 1:

If an error occurs, or the end-of-

file is reached, the return value is a short object count (or zero).

The function fread() does not distinguish between end-of-file and error;

callers must use feof(3) and ferror(3) to determine which occurred. The

function fwrite() returns a value less than nitems only if a write error

has occurred.

Ich würds so machen:

case 1:printf("\n\n\n\tName aller Hauptlieferanten:\n\n");

           while (fread(&vertrag, sizeof(vertrag),1, Dateiptr) != 0)

           {

                printf("\t\t- %s\n",vertrag.liiferant);

           }

           if (feof(Dateiptr) ....


           break;

Zur 2:

Ich verstehe ehrlichgesagt die Aufgabenstellung nicht ganz, aber um eine Liste zu sortieren speicherst du alle Strings in einem String-Array (char **) und übergibst dieses an die Methode qsort. Dann haste es sortiert und kannst damit weiterarbeiten

Zur 3:

Termin einlesen, durch alle Aufträge durchgehen (wie 1) und bei allen Objekten, bei denen das Datum passt, schauen ob Vertrags- und Liefermenge übereinstimmen, wenn nein, ausgeben, das sollte recht einfach im Gegensatz zur 2 sein

//Ach ja, es heißt übrigens Lieferant, nicht Liiferant

Alles klar, wieder was gelernt, naja, habe einfach nur logisch gedacht und es mir so erklärt, wie genau das Standardisiert implementiert ist, wusste ich nicht *gg Fand meine Erklärung ganz logisch, im Prinzip funktioniert sie ja auch immer, es wird ja genau das gemacht, nur das WARUM ist nun klar geworden :-) Und dass es nicht immer so sein muss :-/ Danke Sollte übrigens 4.294.967.295 sein bei 32 bit

Bin nicht sicher ob du es verstanden hast, also fürn PC ist eine Zahl ja nur 0er und 1er, und C prüft da nicht ob du Mist baust^^ Das sind wohl die 2 Denkfehler: 1. Du erwartest wenn unsigned int, dass man keine negativen Werte übergeben kann und 2. hast du in der printf("%d", i) benutzst, statt printf("%u",i).

wenn du hinschreibst:

unsigned int a = -1

Dann tun andere Compiler vielleicht meckern, weil du ja ne Vorzeichenlose Zahl willst, C hingegen wandelt die -1 erstmal in die Binärform um, (die Länge passt ja für nen int): 1111 und speichert sie in der Variable a

Nun hast du die 1111 drin, wenn du sie als signed ausgibst, bekommst du deine "seltsame" negative Zahl, wenn du sie aber als unsigned ausgibst, bekommste 255

Wie gesagt das Beispiel vereinfacht auf 4 Bits pro Integer.

Vielleicht wird es dir klarer, wenn du dir die Hex-form anschaust:

printf("%x",a);

MfG

Also nicht sicher, aber glaube es ist so:

Wenn du nun "unsigned int a= -1;" schreibst, so tut der compiler erst -1 umformen, das wäre 1111 (vereinfacht mit 4 Bits statt Bytes bei 32-Bit-Systemen) und weist es der Variable a zu.

Du tust jetzt mit "%d" ausgeben, das ist signed und er interpretiert die 1111 als -1

Würdest du "%u" benutzen, wäre es unsigned und er würde 255 ausgeben

jo, stimmt, adressen der Methode find() übergeben und nicht p, da adressen ein zeiger ist, wird eine kopie vom Zeiger übergeben auf ein und das gleiche Array, also brauchst keine Angst zu haben, dass das Array sich irg.wie verändert oder so.

dann musst du name dynamisch allokieren, weil man die größe nicht im voraus kennt, oder aber du definierst am anfang mit char* name[50] und liest es am besten mit fgets ein, aber fürn anfang reicht auch gets.

im strcmp prüfst du ob die strings gleich sind, wenn gleich müsstest du auf ==0 prüfen, also:

if (strcmp(adressen->name,name) == 0) dann sind sie gleich

schau dir die Funktionsweise und rückgabewerte von strcmp an.

Studiere Informatik, seit 2,5 Monaten lerne ich C :-D

du kompilierst wohl mit dem Ansi-C89-Standard, da musst du die erst alle Variablen am Anfang eines Blocks derklarieren!

Und ich erkläre mal genau was hierbei passiert:

int main() {

	int i, j;

        t_adresse** adressen;                             //Hier werden Zeiger auf Adressstrukturen gelagert

        t_adresse* adresse;                                //Zeiger der auf eine Adresse zeigt


	printf("Bitte Zahl eingeben: ");

	scanf("%i", &j);                                       //Liest Zahl ein


	adressen=malloc(j * sizeof(t_adresse*));     //Reserviert Speicher für j ZEIGER! die auf die Adressen zeigen


	for (i = 0; i<j; i++) {

		adressen[i] = eingabe();    //Der i. Zeiger im Array adressen zeigt nun auf das in der eingabe() erstellte Adressstrukturobjekt

	}


	//Und immer schön alles freigeben am Ende 

	for (i = 0; i<j; i++) {

		free(adressen[i]);     //Hier wird das erstellte Adressobjekt wieder entfernt

	}

	free(adressen);                //Und nun die Datenstruktur freigeben = entfernen

	return 0;

}[/code]




In eingabe() erstellst du deine Adressstrukturen, in der main() hast du nur Zeiger auf diese...

Also du erstellst in eingabe eine Struktur, den zeiger auf diese gibt die methode zurück:

adresse----->adresstruktur

In der main gibts das Array adressen, in diesem array sind zeiger die auf nichts zeigen,

adressen[0]----->NULL

Wenn du nun adressen[0] = adresse; machst zeigt nun adressen[0] ebenfalls auf die Adressstruktur auf die auch adresse zeigt:

adressen[0] ------> adressstruktur

verständlicher?

Ja genau, und da du das nicht voraus wissen kannst, kannst du das jetzt nicht reincoden, sondern musst den Speicher dann dynamisch allokieren!

z.B:

main(){

int i, j;

printf("Bitte Zahl eingeben: ");

scanf("%i", &j);


t_adresse** adressen=malloc(j * sizeof(t_adresse*));

t_adresse* adresse;


for (i = 0; i<j; i++) {

adressen[i] = eingabe();

}


//Und immer schön alles freen am Ende 

for (i = 0; i<j; i++) {

free(adressen[i]);

}

free adressen;

}

[/code]

siehe scanf-Benutzung:

Du hast das & vergessen

scanf("%i", &speicher->plz);

MfG

So wärs dann in der Art:

int main() {

t_adresse* adressen[5];  //Array von Zeigern auf Adressen

t_adresse* adresse;  //Zeiger auf Adresse

int i; //Zählervariable



for (i = 0; i<5; i++) {

adresse = eingabe();

adressen[i] = adresse;

}


for (i=0; i<5; i++) {

printf("%s", adressen[i]->name);

}

}


t_adresse* eingabe() {


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


return speicher;

}

Das i habe ich in der for-Schleife initialisiert, das hätte man aber genauso gut am Anfang der main() machen können mit int i;

und dann bei der schleife: for (i=0; i<counter; i++) ...

Der globale Zähler, ist einfach nur eine Variable wie jede andere, deren Inhalt nur nicht beim verlassen einer Methode gelöscht wird (so, wie die üblichen lokale Variablen) und von allen Methoden abgefragt und verändert werden kann.

Man hätte den Code auch ohne der globalen lösen können, indem du die Zahl an die Methode eingabe mit übergibst... würde dann etwas anders aussehen das ganze, aber so dachte ich ist es am einfachsten zu verstehen...

Void heißt gar kein Rückgabewert! Brauche ich in dem Beispiel nicht, ich übergebe der Methode eingabe() einen Zeiger auf Adressen, er nutzt diesen Zeiger um in Adressen eine Adresse einzufügen und damit endet auch die Methode, so muss man auch nichts zurückgeben.

Wenn du es unbedingt mit Rückgabe machen willst/musst, würde das auch gehen... müsste man ebenfalls etwas anpassen, aber finds so schöner

Dann machs so:

static int counter=0; //GLOBALER zähler gestartet bei 0!


int main() {

t_adresse* adressen[5];  //Falls du nicht weißt wie viel du brauchst musst du mit malloc und realloc dynamisch allokieren

eingabe(adressen);

eingabe(adressen);

...

for (int i=0; i<counter; i++) {

printf("%s", adressen[i]->name);

}

}


void eingabe(t_adresse** adressen) {   //void da man nichts zurückgibt sondern nur den übergebenen zeiger benutzt


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


adressen[counter] = speicher;

counter++;

}

//So in der Art, nicht getestet!

Jap ^^

ja aber wenn bei mir steht "legen sie ein array von typ blabla" und dann noch als beispiel "typ *name[5];" dasteht dasnn versteh ich das so.

typ *name[5] ist ein array von diesem Typ, also genau was wir gesagt haben, ein array von adressen, und was in meinem codebeispiel drinsteht x)

t_adresse* adressen[5]

adressen---->speicher---------------------------------->t_adresse

                   speicher---------------------------->t_adresse

                   speicher--//entspricht adressen[2] --> usw

                   speicher  //entspricht adressen[3]

                   speicher  // usw.

Code nicht angeschaut, aber unter debugger ist der Fehler hier:

(gdb) n

114	          x->next = NULL; free(x);   //Next-Zeiger von Element wo x drauf zeigt=NULL; Speicher freigeben

(gdb) n

115	          N--;                       //Listenl�nge um 1 verringern

(gdb) n

41	     while (First->next!=NULL || Erstes->next!=NULL)

(gdb) n


Program received signal SIGSEGV, Segmentation fault.

0x080488b1 in main () at Aufgabe3fertig.c:41

Ich denke irg.wann zeigt das x auf First oder Erstes, du tust x freigeben, damit auch das worauf First oder Erstes hinzeigt und beim Zugriff auf das bereits gefreete Element gibts den segmentation fault.

Könntest du vll noch ein Bsp. machen, habe die Aufgabe immernoch nicht 100% durchgeblickt, also du erstellst eine x-Elementige liste und dann tust du diese in eine Warteschlange umbauen, also da wo man immer das Element vorne einfügt und rausnimmt, stimmts?

Darfst du nicht gleich eine Queue implementieren? Wäre viel weniger zu schreiben...