Wäre nett, wenn ihr mir helft ;)

der-sibbi

alsoo, hab mich gestern abend nochmal an die sache rangesetzt. bin auch meines erachtens "weit" gekommen.

// Headerdateien
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

// Deklarationen
float r1, r2, rr, rp,rrMIO, rrKO, rrMO, rpMIO, rpKO, rpMO;

// Starten der Hauptfunktion
int main(int argc, char *argv[])
{
        // Ausgabe von Willkommen und Programmerklärung
		printf("\n\n\tHerzlich Willkommen,\n");
		printf("\tdieses Programm hilft Ihnen dabei, den Gesamtwiderstand bei einer");
		printf("\t\tReihen- und Parallelschaltung zu errechnen.\n\n\n");

		// Eingabedialog von R1
		printf("Bitte R1 eingeben: ");
		scanf_s("%f", &r1);

		// Vergleich ob r1 kleiner oder gleich 0 ist
		if (r1<=0)
		{
			// Falls zutreffend: Fehlermeldung und Programm beenden
			printf("\nFehler: Bitte nur positive Werte ueber 0 eingeben !!!\a");
			printf("\n\n\nDas Programm wird beendet.\n");
			exit(0);
		}

		// Eingabedialog von R2
		printf("Bitte R2 eingeben: ");
		scanf_s("%f", &r2);

		// Vergleich ob r2 kleiner oder gleich 0 ist
		if (r2<=0)
		{
			// Falls zutreffend: Fehlermeldung und Programm beenden
			printf("\nFehler: Bitte nur positive Werte ueber 0 eingeben !!!\a");
			printf("\n\n\nDas Programm wird beendet.\n");
			exit(0);
		}

		// Neue Zeile
		printf("\n");

		// Rechnung von rr
		rr=r1+r2;

		// Rechnung von rp
		rp=(r1*r2)/(r1+r2);

		// Vergleich ob rr kleiner als 1 ist
		if (rr<1)
		{
			// Falls zutreffend: rr umrechnen zu mOhm und Ausgabe in mOhm
			rrMIO=rr*1000;
			printf("Bei der Reihenschaltung betreagt der Widerstand in mOhm: %f",rrMIO);
			printf("\n");
		}

		else
		{
			// Vergleich ob rr größer oder gleich 1 und kleiner als 1000 ist
			if ((rr>=1) & (rr<1000))
			{
				// Falls zutreffend: Ausgabe von rr in Ohm
				printf("Bei der Reihenschaltung betreagt der Widerstand in Ohm: %f",rr);
				printf("\n");
			}

			else
			{
				// Vergleich ob rr größer oder gleich 1000 und kleiner als 1000000 it
				if ((rr>=1000) & (rr<1000000))
				{
					// Falls zutreffend: rr umrechnen zu kOhm und Ausgabe in kOhm
					rrKO=rr/1000;
					printf("Bei der Reihenschaltung betreagt der Widerstand in kOhm: %f",rrKO);
					printf("\n");
				}

				else
				{
					// Vergleich ob rr größer als 1000000 ist
					if (rr>1000000)
					{
						// Falls zutreffend: rr umrechnen zu MOhm und Ausgabe in MOhm
						rrMO=rr/1000000;
						printf("Bei der Reihenschaltung betreagt der Widerstand in MOhm: %f",rrMO);
						printf("\n");
					}
				}
			}
		}

		// Vergleich ob rp kleiner als 1 ist
		if (rp<1)
		{
			// Falls zutreffend: rp umrechnen zu mOhm und Ausgabe in mOhm
			rpMIO=rp*1000;
			printf("Bei der Parallelschaltung betreagt der Widerstand in mOhm: %f",rpMIO);
			printf("\n");
		}
		else
		{
			// Vergleich ob rp größer oder gleich 1 und kleiner als 1000 ist
			if ((rp>=1) & (rp<1000))
			{
				// Falls zutreffend: Ausgabe von rp in Ohm
				printf("Bei der Parallelschaltung betreagt der Widerstand in Ohm %f",rp);
				printf("\n");
			}

			else
			{
				// Vergleich ob rp größer oder gleich 1000 und kleiner als 1000000 ist
				if ((rp>=1000) & (rp<1000000))
				{
					// Falls zutreffend: rp umrechnen zu kOhm und Ausgabe in kOhm
					rpKO=rr/1000;
					printf("Bei der Parallelschaltung betreagt der Widerstand in kOhm %f",rpKO);
					printf("\n");
				}

				else
				{
					// Vergleich ob rp größer oder gleich 1000000 ist
					if (rp>=1000000)
					{
						// Falls zutreffend: rp umrechnen zu MOhm und Ausgabe in MOhm
						rpMO=rp/1000000;
						printf("Bei der Parallelschaltung betreagt der Widerstand in MOhm: %f",rpMO);
						printf("\n");
					}
				}
			}
		}

		// Ausgebae zum beenden
		printf("\n\n\nZum beenden: ");

	return 0;
}

nur teil vier, also das mit der schleife, damit ich beliebig viele widerstände einlesen kann bekomme ich nicht wirklich auf die kette.

und noch eine frage: wie kann ich bei der ausgabe die dezimalstellen auf zwei begrenzen ?

supertux: ich hab mir dieses tutorial nicht genauer angesehen aber es ist wohl besser zu "versuchen" jemanden zu helfen als "von oben herab" zu argumentieren

Konfusius

um beliebig viele widerstände einzulesen brauchst du ein array, dh du benutzt anstelle der variablen r1 und r2 ein array, zb r[256].

dann packst du den eingabebefehl in eine schleife, die so lange widerstände einliest, bis null als endebedingung eingegeben wird.

danach berechnest du in einer schleife rr und rp aus den werten des arrays.

der-sibbi

puh, von arrays hab ja mal gar keine ahnung .. aber mal sehen ob ich was finde & es hinbekomme

BorisDieKlinge

Array:

statt:

double r1,r2,r3,......;

r1= a;
r2= b;
r3= c;
.
.
.

machst du:

double rArray[500]; //Array mit 500 double werten (index 0-499)

rArray[0]=a;
rArray[1]=b;
rArray[2]=c;
.
.
.

denke das ist selbsterklärend;)

So aber nun musst du noch wissen was ne Schleife ist^^

@BorisDieKlinge: danke, kann ich den speicher auch über die array grenzen hinweg ansprechen? also könnte ich auch mit rArray[600] eine speicherzelle ansprechen, die 100*sizeof(double) bytes hinter dem rArray liegt? ist das möglich?

BorisDieKlinge

nein. Warum willst du das tun macht kein sinn oder? Du reservierst so statisch ein Array mit 500 werten. Wenn du mehr willst dann mach 600. Wenn du es dynamisch willst gehts es ganz anderes (aber das wäre zuviel für dich).

Entscheide dich wieviel werte du max. berechnen lassen willst, und mach so graoß dein array.

Tachyon

sibbi schrieb:

@BorisDieKlinge: danke, kann ich den speicher auch über die array grenzen hinweg ansprechen? also könnte ich auch mit rArray[600] eine speicherzelle ansprechen, die 100*sizeof(double) bytes hinter dem rArray liegt? ist das möglich?

Klar, möglich ist das. Der C-Compiler wird Dir auch nicht sagen, dass Du auf das 601 Element von einem Array mit 600 Elementen zugreifst. Oftmals wird Dir auch das Laufzeitsystem nichts sagen.
Das Programmverhalten ist nicht mehr definiert, und es kann alles mögliche passieren. Wenn Du Glück hast, schmiert das Programm gleich beim ersten Start ab. Wenn Du Pech hast, passiert sporadisch irgendwelcher Blödsinn, der sich nur schwer reproduzieren lässt und schwer aufzuspüren ist.

der-sibbi

sibbi schrieb:

@BorisDieKlinge: danke, kann ich den speicher auch über die array grenzen hinweg ansprechen? also könnte ich auch mit rArray[600] eine speicherzelle ansprechen, die 100*sizeof(double) bytes hinter dem rArray liegt? ist das möglich?

das hab ich garnicht geschrieben. muss das irgentwie so hinkriegen, dass das programm fragt, wie viele widerstände ich eingeben möchte. angenommen ich gebe 6 ein. dann sollen ausgaben folgen wie: "Bitte geben Sie den 1. Widerstand ein:", "Bitte geben Sie den 2. Widerstand ein", und so weiter, bis (in diesen bsp jetzt) zum 6. widerstand. mittlerweile weiss ich, dass ich da mit arrays und schleifen arbeiten muss. nur bin da leider mit überfragt. hab mir auch schon das ein oder andere tutorial durchgelesen aber naja, wird irgentwie nie so wie ichs haben möchte bzw. haben muss

Nagila Hawa

Du brauchst nicht zwingend ein Array für die letzte Aufgabe.

unsigned int eingabe;
unsigned int produkt = 1;
unsigned int summe = 0;

Jetzt brauchst du nur noch die Widerstände nacheinander einlesen, bis der Benutzer keine Lust mehr hat und jeweils zu produkt und summe hinzurechnen. Am Ende ist summe der Reihenwiderstand und produkt / summe (bei summe != 0) der Parallelwiderstand.

Pass jedoch auf, daß produkt nicht überläuft. Eventuell vor dem Überlaufen entsprechend zu KOhm, MegOhm umwandeln. Ist aber vermutlich für die Aufgabe uninteressant.

Gustl

BorisDieKlinge schrieb:

nein. Warum willst du das tun macht kein sinn oder? Du reservierst so statisch ein Array mit 500 werten. Wenn du mehr willst dann mach 600. Wenn du es dynamisch willst gehts es ganz anderes (aber das wäre zuviel für dich).

Entscheide dich wieviel werte du max. berechnen lassen willst, und mach so graoß dein array.

Hi,
für mich wäre jetzt interessant wie das ganze dynamisch aussieht.
Könnte mir das einer and diesem simplen beispiel erklären?
MfG Gustl

Korhil

Gustl schrieb:

BorisDieKlinge schrieb:

nein. Warum willst du das tun macht kein sinn oder? Du reservierst so statisch ein Array mit 500 werten. Wenn du mehr willst dann mach 600. Wenn du es dynamisch willst gehts es ganz anderes (aber das wäre zuviel für dich).

Entscheide dich wieviel werte du max. berechnen lassen willst, und mach so graoß dein array.

Hi,
für mich wäre jetzt interessant wie das ganze dynamisch aussieht.
Könnte mir das einer and diesem simplen beispiel erklären?
MfG Gustl

int *Wiederstaende;
   int Anzahl;
   printf("Wie viele Werte benötigen Sie : ");
   scanf("%d", &Anzahl);
   Wiederstaende = (int *)malloc(Anzahl*sizeof(int));

Ich hoffe das Beispiel hilft dir weiter. Mit malloc wird während der Laufzeit Speicherplatz reserviert.

Konfusius schrieb:

um beliebig viele widerstände einzulesen brauchst du ein array, dh du benutzt anstelle der variablen r1 und r2 ein array, zb r[256].

256 ist alles andere als 'beliebig'. aber davon mal abgesehen, man könnte ja auch jeden neuen wert mit dem vorherigen zwischenergebnis sofort verrechnen. dann braucht man kein array und kann trotzdem sehr viele werte verarbeiten.

double *pArray;
int iAnz;
.
.
.
//Dyn array erzeugen
pArray= malloc(sizeof(*pArray)*iAnz);

.
.
//BERECHNEN

//Dyn array freigeben
free(pArray);