Unterprogramme - Rechner

Th69

ergebnis = add(ergebnis,zahl);

...

//Definition der Additions-Funktion
int add(int x, int y)
{
   return x + y;
}

Du mußt schon verstehen (wollen), was die Parameter und Rückgabewerte einer Funktion sind.

Und entferne die globalen Variablen und packe sie in die main-Funktion:

int main()
{
    int zahl;
    int ergebnis=0;

    ...
}

Und mein Tipp mit dem Debugger gilt immer noch -)

unskilled

int add(int, int) //Definition einer Funktion 
    { 
      return zahl + ergebnis; 
    }

was soll add machen?
richtig, sie(die funktion) soll die beiden parameter, die ihr übergeben wurden, addieren - aber deine addiert einfach 2 globale variablen(die du dazu noch nicht mal brauchst!)

int add(int lhs, int rhs)
{
  return lhs + rhs;
}

int main()
{
 int a = 23;
 int b = 3;

 int x = add(a, b);
}

so wird eine funktion aufgerufen...

bb

sezai11

okay die funktionsaufrufer funktionieren nun, vielen dank dafür
hab nun versucht eine hochrechnung einzubauen, allerdings bekomme ich folgende fehlermeldung, die ich *tadaa* natürlich nicht versteh:

Fehler 1 error C2668: 'pow': Mehrdeutiger Aufruf einer überladenen Funktion c:\Users\sezai11\Documents\Visual Studio 2008\Projects\Uni_Prog1\testing\testing.cpp 58

#include <iostream>
#include <math.h>

using namespace std;

int plus(int, int);
int minus(int, int);
int mal(int, int);
int durch(int, int);
int hoch(int, int);

int main()
{
	int ergebnis=0;
	int zahl;
	bool abfrage=true;
	char zeichen;

	while(abfrage)
	{
		cout << ergebnis;
		cin >> zeichen;
		switch(zeichen)
		{
		case '+':cin >> zahl;ergebnis=plus(ergebnis, zahl); break;
		case '-':cin >> zahl;ergebnis=minus(ergebnis, zahl); break;
		case '*':cin >> zahl;ergebnis=mal(ergebnis, zahl); break;
		case '/':cin >> zahl;if(zahl!=0){ergebnis=durch(ergebnis, zahl);}else{cout << "nicht durch 0 teilen\n";} break;
		case '^':cin >> zahl;ergebnis=hoch(ergebnis, zahl); break;
		case 'c':ergebnis=0; break;
		case 'e':abfrage=false; break;
		default:cout << "bitte Rechenzeichen eingeben\n";break;
		}
	}
}

int plus(int lhs, int rhs)
{
	return lhs + rhs;
}

int minus(int lhs, int rhs)
{
	return lhs - rhs;
}

int mal(int lhs, int rhs)
{
	return lhs * rhs;
}

int durch(int lhs, int rhs)
{
	return lhs / rhs;
}
int hoch(int lhs, int rhs)
{
	return pow(lhs,rhs);
}

unskilled

sezai11 schrieb:

okay die funktionsaufrufer funktionieren nun, vielen dank dafür

np - ich hoffe, du hast dir das kapitel in deinem buch noch ma durchgelesen, sonst weist du es das nächste mal wieder nicht!?

hab nun versucht eine hochrechnung einzubauen, allerdings bekomme ich folgende fehlermeldung, die ich *tadaa* natürlich nicht versteh:

Fehler 1 error C2668: 'pow': Mehrdeutiger Aufruf einer überladenen Funktion c:\Users\sezai11\Documents\Visual Studio 2008\Projects\Uni_Prog1\testing\testing.cpp 58

du rufst eine fkt(pow) auf und der compiler weiß nicht, welche version du meinst - es gibt mehrere, die gleich gut(schlecht^^) passen ;o)

#include <iostream>
#include <math.h>

der header heißt cmath und nicht math.h

int plus(int, int);
int minus(int, int);
int mal(int, int);
int durch(int, int);
int hoch(int, int);

hier ists zwar noch nicht das problem, aber normalerweise solltest du auch in prototypen die parameternamen mitschreiben...

in C++ deklariert man variablen überigens so lokal wie möglich...
also steck das int zahl und char zeichen mal in die schleife an den anfang...
ergebnis würde ich außerhalb lassen, weil man idR erst das ergebnis ausgibt, wenn man fertig ist, aber ist ok^^

switch(zeichen)
		{
		case '+':cin >> zahl;ergebnis=plus(ergebnis, zahl); break;
		case '-':cin >> zahl;ergebnis=minus(ergebnis, zahl); break;
		case '*':cin >> zahl;ergebnis=mal(ergebnis, zahl); break;
		case '/':cin >> zahl;if(zahl!=0){ergebnis=durch(ergebnis, zahl);}else{cout << "nicht durch 0 teilen\n";} break;
		case '^':cin >> zahl;ergebnis=hoch(ergebnis, zahl); break;
		case 'c':ergebnis=0; break;
		case 'e':abfrage=false; break;
		default:cout << "bitte Rechenzeichen eingeben\n";break;
		}

rück das doch mal vernünftig ein...

int plus(int lhs, int rhs)
{
	return lhs + rhs;
}

dir ist klar, dass du die parameter auch anders nennen kannst?
falls du dich fragst, was das bedeutet:
lhs = left hand side = linker parameter
rhs = right ........ = rechter parameter
(sind imho sehr übliche bezeichner bei solchen fkt)
die namen machen aber spätestens bei hoch keinen sinn mehr ;o)

int hoch(int lhs, int rhs)
{
	return pow(lhs,rhs);
}

hier ist das problem: er kennt kein pow, was 2 int`s als parameter möchte, also musst du mind. einmal casten(den rest macht dann der compiler für dich und warnt dich ggf. davor, dass er das tut) oder ne eigene fkt schreiben...
kannst dich ja mal versuchen!?

bb

sezai11

ja hab mich nochmal durchgegoogled hab da so 3 sources im netz mit denen ich mich befasse zum lernen. das das ergebnis übrigends am anfang ausgegeben wird war teil der aufgabe, darum stehst vorn das mit den parameternamen hab ich mir gedacht, aber bin da manchmal bissl denkfaul...

eine kurze frage was meinst du mit "casten".?
//edit schon gefunden

sezai11

habs

int hoch(int lhs, int rhs)
{
	return (double) pow((double)lhs,(double)rhs);
}

Mr X

Gut!

Ich würde allerdings statt

(double)lhs

static_cast<double>(lhs)

schreiben. Ist "moderner" und dank Klammern besser zu überblicken, was gecastet wird...

volkard

Mr X schrieb:

Gut!

Ich würde allerdings statt
(double)lhs
static_cast<double>(lhs)
schreiben. Ist "moderner" und dank Klammern besser zu überblicken, was gecastet wird...

Oder

double(lhs)

Ist "auch moderner" und dank der Klammern und wenig Drumherumfug auch noch besser zu überblicken, was gecastet wird...

unskilled

sezai11 schrieb:

habs

int hoch(int lhs, int rhs)
{
	return (double) pow((double)lhs,(double)rhs);
}

ja - klar fangt wieder an, zu erzählen, wie er casten soll, bevor ihr den code anguckt...
ein cast ist komplett dumm, einer ist nicht notwendig und der andere ist zumindest fragwürdig
wieso willst du das ergebnis von pow noch nach double casten? (was es ohnehin schon ist, obwohl du nen int zurückgibst)
wieso reicht nicht auch float sondern muss es double sein?
die richtige pow überladung wäre float pow(float, int) ;P

ich bevorzuge auch den ctor-cast, also:

int hoch(int basis, int exponent)
{
  float r = pow(float(basis), exponent);
  return int(r);
}

das kann man natürlich auch in eine zeile schreiben, aber das sind mir persönlich zu viele klammern^^

ich wäre noch immer dafür, die fkt selbst zu schreiben - wieso sollte man sich die beiden casts und deren nachteile einhandeln, wenn es auch ohne geht? Oo
schneller wird es so auch nicht unbedingt sein...

bb

SeppJ

Vor allem wird int(r) des öfteren mal nicht das liefern was man erwartet, weil konsequent abgerundet wird. Wenn man Integerpotenzen haben will, ist es doch leicht die eben selbst zu programmieren.