4. kann man noch was verbessern ???

kann man noch was verbessern ???

  • S

    N'abend allerseits,
    wir haben gestern in INF folgende Aufgabe bekommen:
    Aufgabe 1:
    Verfeinern Sie den Algorithmus zur Division aus der Vorlesung V2 auf die Weise,
    dass er von einem Rechenwerk durchgeführt werden kann,
    das nur plus und minus rechnen, sowie Zahlen vergleichen kann.
    Divisionsalgorithmus 84/16

    Habe mich erst seit gestern abend intensiv mit C beschäftigt, vorher habe ich nur C++ geschrieben.....

    Also wenn Ihr noch verbesserungsvorschläge habt,

    hier der Code,
    viel Spaß 🙂

    // Übungsblatt 2 Aufgabe 1)

#include <stdio.h>

void main(void)
{
	int z, n, m, e, f, x, y;
	int vk, nk1, nk2;

	z = 84;
	n = 16;
	e = z;
	m = 0;
//-----------------------------------------------
//			Bestimmen, wie oft n in z geht	   //
//-----------------------------------------------

	while (e >= n)
	{	
		e = z - n;
		z = e;
		m++;
	}

	vk = m;

//-----------------------------------------------
//			n geht m mal in z, Rest e		   //
//-----------------------------------------------

	printf("Vor Komma: %d\n", m);
	printf("Rest: %d\n", e);

//-----------------------------------------------
//			Rest e auf das 10fache erhöhen	   //
//-----------------------------------------------
	f = e;
	x = 0;
	y = 0;

	while (x < 9)
	{
		y = f + e;
		f = y;
		x++;
	}

	printf("Rest*10: %d\n", f);

//-----------------------------------------------
//			Bestimmen, wie oft n in f geht	   //
//-----------------------------------------------
	e = f;
	m = 0;

	while (e >= n)
	{	
		e = f - n;
		f = e;
		m++;
	}

	nk1 = m;

//-----------------------------------------------
//			n geht m mal in z, Rest e		   //
//-----------------------------------------------

	printf("1. Nach Komma: %d\n", m);
	printf("Rest: %d\n", e);

//-----------------------------------------------
//			Rest e auf das 10fache erhöhen	   //
//-----------------------------------------------
	f = e;
	x = 0;
	y = 0;

	while (x < 9)
	{
		y = f + e;
		f = y;
		x++;
	}

	printf("Rest*10: %d\n", f);

//-----------------------------------------------
//			Bestimmen, wie oft n in f geht	   //
//-----------------------------------------------
	e = f;
	m = 0;

	while (e >= n)
	{	
		e = f - n;
		f = e;
		m++;
	}

	nk2 = m;

	printf("2. Nach Komma: %d\n", m);

//-----------------------------------------------
//			Ausgabe von gesamt Berechnung	   //
//-----------------------------------------------
	printf("____________________");
	printf("\n\nGesamtergebnis: %d,%d%d\n\n", vk,nk1,nk2);

}

    hier die Ausgabe auf dem Schirm:

    Vor Komma: 5
Rest: 4
Rest*10: 40
1. Nach Komma: 2
Rest: 8
Rest*10: 80
2. Nach Komma: 5
____________________

Gesamtergebnis: 5,25

Press any key to continue

    Danke

    0
  • ?

    Zuerst mal heißt das

    int main(void)

    So, wies da steht, ist es kein gültiger C-Code. (In C++ wäre void main übrigens auch unzulässig).

    Ansonsten würde ich dir empfehlen, sprechendere Variablennamen zu benutzen und die while- durch for-schleifen zu ersetzen, wos sinnvoll ist (also überall, wo du nen Zähler benutzt).

    0
  • D

    😮 von Funktionen schon was gehört 😮

    0
  • D

    intensiv mit C beschäftigt, vorher habe ich nur C++ geschrieben.....

    Eh klar...

    0
  • S

    Funktionen ?? Nöö was ist das.....

    natürlich hab ich schon was von funktionen gehört...
    habe auch schon jede menge damit rumhantiert...
    nur leider funktioniert da irgendwas nicht, wenn ich versuche das mit Funktionen
    zu machen. In der Uni an den Rechnern laufen die Programme, hier zu hause
    schmieren sie beim Ausführen ab und geben ne Error-msg aus, welche nach Adresskonflikten aussieht ??? Ziemlich beschissen.... unten im Keller habe ich
    ne andere Version von c++ (autorenversion) da läuft es auch...
    aber ich baue da nochmal die funktionen rein und poste es dann hier nochmal,
    dennoch besten Dank,

    Gut Nächtle

    0
  • S

    So hier also mit Funktionen,

    // Übungsblatt 2 Aufgabe 1)

#include <stdio.h>

	int z, n, m, e, f, x, y;	// Variablen sind global deklariert,
	int vk, nk1, nk2;			// ermöglicht fkt1&fkt2 den Zugriff

void main(void)
{

	int fkt1();					// Prototyp Funktion 1
	int fkt2();					// Prototyp Funktion 2

	z = 84;
	n = 16;
	e = z;
	m = 0;
//-----------------------------------------------
//			Bestimmen, wie oft n in z geht	   //
//-----------------------------------------------

	while (e >= n)
	{	
		e = z - n;
		z = e;
		m++;
	}

	vk = m;

//-----------------------------------------------
//			n geht m mal in z, Rest e		   //
//-----------------------------------------------

	printf("Vor Komma: %d\n", m);
	printf("Rest: %d\n", e);

//-----------------------------------------------
// Rest e auf das 10fache erhöhen, Aufruf fkt1 //
//-----------------------------------------------

	fkt1();
	printf("Rest*10: %d\n", f);

//-----------------------------------------------
//			Bestimmen, wie oft n in f geht	   //
//-----------------------------------------------
	fkt2();	
	nk1 = m;

//-----------------------------------------------
//			n geht m mal in z, Rest e		   //
//-----------------------------------------------

	printf("1. Nach Komma: %d\n", m);
	printf("Rest: %d\n", e);

//-----------------------------------------------
// Rest e auf das 10fache erhöhen, Aufruf fkt1 //
//-----------------------------------------------

	fkt1();
	printf("Rest*10: %d\n", f);

//-----------------------------------------------
//			Bestimmen, wie oft n in f geht	   //
//-----------------------------------------------
	fkt2();
	nk2 = m;
	printf("2. Nach Komma: %d\n", m);

//-----------------------------------------------
//			Ausgabe von gesamt Berechnung	   //
//-----------------------------------------------
	printf("____________________");
	printf("\n\nGesamtergebnis: %d,%d%d\n\n", vk,nk1,nk2);

}

//-----------------------------------------------
//			fkt1, erhöht e auf das 10-fache	   //
//-----------------------------------------------
int fkt1()
{
	f = e;
	x = 0;
	y = 0;

	while (x < 9)
	{
		y = f + e;
		f = y;
		x++;
	}
	return f;
}

//-----------------------------------------------
//			fkt2, bestimmt wie oft n in f geht //
//-----------------------------------------------
int fkt2()
{
	e = f;
	m = 0;

	while (e >= n)
	{	
		e = f - n;
		f = e;
		m++;
	}
	return m;
}

    Nun aber wirklich gute N8 😃

    0
  • A

    Ein Manko bleibt:
    Du verwendest keine sprechenden Namen!!

    Unter fkt1() kann ich mir hald wenig vorstellen, was die Funktion macht. Und welche Funktion haben die Variablen?? Da steht immer nur ein einzelner Buchstabe, der mir nicht viel sagt. Ich zweifle zwar nicht daran, dass ich verstehen würde, wofür deine ganzen Variablen und Funktionen sind, aber hald erst, wenn ich deinen ganzen Quellcode durchstudiert habe. Jetzt geht das noch ganz leicht, aber bei größeren Projekten, in denen Unmengen von Quellcode geschrieben wird, ist es einfach wichtig, dass die ganzen Namen sprechend sind!

    Auf eine Nummerierung von Funktionen und Variablen würde ich sowieso verzichten.

    0
  • S

    also, ich glaube, du liest die Posts nicht: int main hat beefy gesagt, und Recht hat er.

    0
  • Y

    supertux schrieb:

    also, ich glaube, du liest die Posts nicht: int main hat beefy gesagt, und Recht hat er.

    Das ist imo eins der Probleme, dass solche Standards immer mal geändert werden. Früher war afaik void noch zulässig für die mainfunktion. Jedenfalls basieren viele ältere Tutorials noch auf dieser Schreibweise wodurch man es teils falsch lernt. Und manche Compiler scheinen da wohl keinen Fehler oder wenigstens eine Warnung auszugeben.

    Btw. Hat ein C-Main-Programm nicht auch noch Parameter?

    0
  • S

    Ynnus schrieb:

    Btw. Hat ein C-Main-Programm nicht auch noch Parameter?

    nein. Nach ANSI C sind erlaubt:

    int main(void);
int main(int argc, char* argv[]);
int main(int argc, char** argv);
    0
  • S

    Jo stimmt ich nehme sonst ja auch immer

    int main()      //oder
int main(void)
{
.
.
.
return 0;
}

    den scheiß mit

    void main(void)

    habe ich von unserem Prof., habe mich auch gefragt, was das soll, wieso der das so macht, aber halt nicht weiter drüber gegrübelt und den scheiss einfach ma so abgepinnt.....

    Best THX

    0
  • S

    Um mal auf das wesentliche zu kommen:

    die Funktionen sind so wie sie sind suboptimal.

    Man versucht nämlich keine globalen Variablen zu haben (sonst sind die Funktionen ja kein bisschen wieder verwendbar)

    deshalb:

    #include<stdio.h>
#include<assert.h>

int div(int divident, int divisor, int* rest)
{
  int ergebnis=0;

  assert(divisor!=0);

  while(divident-divisor > 0)
  {
    divident-=divisor;
    ++ergebnis;
  }

  if(rest)
    *rest=divident;

  return ergebnis;
}

int main(void)
{
  int divident=10;
  int divisor=3;
  int rest;

  int ergebnis=div(divident, divisor, &rest);
  printf("%d / %d == %d und %d Rest\n", divident, divisor, ergebnis, rest);
  return 0;
}

    so ist es gleich viel schöner.

    versuch mal, deinen code auf diese art neuzuschreiben, denn so wie er jetzt ist, ist es eine kleine katastrophe 😉

    0
  • S

    Danke für die vielen Antworten,
    @Shade, wenn ich denn code so schreiben würde, hätte ich ja bei der Division von 84/16 das Ergebnis 5 und den Rest 4 (könnte den Rest auch mit dem Modulo oper bzw. Funkt. bestimmen).... dann müsste ich aber immer noch hingehen, und den rest auf das 10fache erhöhen, damit das folgende Ergebnis eine stelle weiter nach hinten rutscht und ich nen Komma vorschreiben muss....
    dann habe ich da stehen: Ergebnis 5 Rest 4, nun muss ich den Rest noch 9mal zu sich selbst addieren, weil ich ja nicht multiplizieren darf.... dann teile ich den rest wieder, um die 1. nachkommastelle zu erhalten, dann wiederhole ich das ganze mit dem rest und erhalte das entgültige ergebnis 5,25....
    also nochmal in der übersicht:

    1. 84-16-16....bis ein rest < als 16 überbleibt, bzw = 0 (hier 5mal)
    2. Rest (hier 4) auf das 10fache erhöhen, also 4+4+4.... (keine multiplikation verwenden..)
    3. die so gewonnene 40 wieder -16... bis Rest < 16, bzw = 0 (hier 2 mal)
    4. Rest (hier 😎 auf das 10fache erhöhen, also 8+8+8.... (keine multiplikation verwenden..)
    5. die so gewonnene 80 wieder -16... bis Rest < 16, bzw = 0 (hier 5 mal)
    6. Ausgabe 5,25

    Deshalb sieht das ja so chaotisch aus....
    ich wüsste nu auch auf Anhieb net, wie ich den nach deinem Schema umbuxeln sollte...
    kleinen Tipp für mich vielleicht parat ??? 😃 😕

    0
Anmelden zum Antworten