C++ Compilerfehler

Hallo, hab heute mal mit structs angefangen und dabei Ubuntu installiert + Netbeans IDE, nun hab ich versucht ein Telefonbuch zu schreiben:

#include <iostream>
#include <string.h>
using namespace std;

struct telefonbuch
{
    string name[10];
    string addresse[10];
    long nummer[10];
    int nochmal;

};
void eingabe(struct telefonbuch *ptr);
void ausgabe(struct telefonbuch *ptr);
int main()
{
    struct telefonbuch buch;
    struct telefonbuch *ptr;
    ptr=&buch;
    eingabe(ptr);

}
void eingabe(struct telefonbuch *ptr)
{
    do
    {
    for(int x=1;x<=10;x++)
    {
        cout<<"Geben sie den "<<x<<" Namen ein: ";
        cin>>ptr->name[x];
        cout<<endl<<"Geben sie die "<<x<<" Adresse ein: ";
        cin>>ptr->addresse;
        cout<<endl<<"Geben sie die "<<x<<" Telefonnummer ein: ";
        cin>>ptr->nummer;

    }

    cout<<"Das Telefonbuch ist gefüllt, umd die Eingaben nochmals zu"<<endl<<" tätigen drücken sie die 0, zum Anzeigen die 1: ";
    cin>>ptr->nochmal;
    } while(ptr->nochmal==0);

    }
void ausgabe(struct telefonbuch *ptr)
{
    for(int x=1;x<=10;x++)
    {
     cout<<endl<<x<<". Name: "<<ptr->name[x]<<" Adresse: "<<ptr->addresse<<" Telefonnummer: "<<ptr->nummer;
    }
}

Leider tritt eine menge Unbekannter Fehler auf, kann mir jemand helfen?

/usr/bin/make -f nbproject/Makefile-Debug.mk SUBPROJECTS= .build-conf
make[1]: Betrete Verzeichnis '/home/dev/NetBeansProjects/CppApplication_1'
/usr/bin/make  -f nbproject/Makefile-Debug.mk dist/Debug/GNU-Linux-x86/cppapplication_1
make[2]: Betrete Verzeichnis '/home/dev/NetBeansProjects/CppApplication_1'
mkdir -p build/Debug/GNU-Linux-x86
rm -f build/Debug/GNU-Linux-x86/main.o.d
g++    -c -g -MMD -MP -MF build/Debug/GNU-Linux-x86/main.o.d -o build/Debug/GNU-Linux-x86/main.o main.cpp
main.cpp: In function ‘void eingabe(telefonbuch*)’:
main.cpp:33: error: no match for ‘operator>>’ in ‘std::cin >> ptr->telefonbuch::addresse’
/usr/include/c++/4.4/istream:119: note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>& (*)(std::basic_istream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:123: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:130: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:166: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(bool&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:170: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:173: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:177: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:180: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:184: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:188: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:193: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long long int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:197: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:202: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(float&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:206: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(double&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:210: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long double&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:214: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(void*&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:238: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
main.cpp:35: error: no match for ‘operator>>’ in ‘std::cin >> ptr->telefonbuch::nummer’
/usr/include/c++/4.4/istream:119: note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>& (*)(std::basic_istream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:123: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:130: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:166: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(bool&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:170: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:173: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:177: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:180: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:184: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:188: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:193: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long long int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:197: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:202: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(float&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:206: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(double&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:210: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(long double&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:214: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(void*&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/istream:238: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
main.cpp: In function ‘void ausgabe(telefonbuch*)’:
main.cpp:49: error: ‘x’ was not declared in this scope
main.cpp:53: error: expected ‘;’ before ‘}’ token
make[2]: *** [build/Debug/GNU-Linux-x86/main.o] Fehler 1
make[2]: Verlasse Verzeichnis '/home/dev/NetBeansProjects/CppApplication_1'
make[1]: *** [.build-conf] Fehler 2
make[1]: Verlasse Verzeichnis '/home/dev/NetBeansProjects/CppApplication_1'
make: *** [.build-impl] Fehler 2
BUILD FAILED (exit value 2, total time: 1s)

SeppJ

cin>>ptr->addresse[x];
      cin>>ptr->nummer[x];

P.S.: Dein Design ist äußerst suboptimal. Eine Telefonnummer ist beispielsweise keine Zahl, sondern eine Ziffernfolge. Außerdem bietet es sich an, einen Eintrag selbst als Klasse zu modellieren und im Telefonbuch dann eine Liste von Einträgen zu speichern.

Durch Verwendung von C++-Mitteln (Referenzen, STL-Container) könntest du dir auch eine Menge potentielle Schwierigkeiten (was wenn mehr als 10 Einträge gemacht werden?) ersparen.

Noch ein Fehler: Der Header heißt string, nicht string.h. In string.h stehen ganz andere Sachen als in string. Dein Programm funktioniert bloß, weil iostream bei dir anscheinend schon string einbindet (muss es im allgemeinen aber nicht).

#include <string> // und nicht string.h

Athar

Ein paar Kommentare zum Code:
1. Ein Telefonbucheintrag sollte eine eigene Klasse sein.
2. "nochmal" ist keine Eigenschaft eines Telefonbuchs, hat dort also auch nichts zu suchen.
3. Der Header für std::string heißt string (ohne .h).
4. Die "struct"s vor telefonbuch gehören außer bei der eigentlichen Klassendefinition dort nicht hin.
5. Was möchtest du mit struct telefonbuch *ptr; ptr=&buch; in main erreichen?
6. Benutze Referenzen statt Zeiger für nichtoptionale Funktionsparameter.
7. Was Zeile 33 und 35 angeht: sieh nach, wie du es in Z.31 gemacht hast.
8. for(int x=1;x<=10;x++) in eingabe und ausgabe ist falsch. Arrayindizes fangen bei 0 an. Im Body der Schleife in ausgabe ist ebenfalls ein Fehler nach Art von 7.

Danke Jung hat jetzt soweit hingehauen, möchte nun als übung ein Taschenrechner mit Structs und Pointern programmieren.
Dachte ersteinmal an unterstrukturen:

struct rechnervar
{
    {
        long summand1;
        long summand2;
    }add;

    {
        long minuent1;
        long minuent2;
    }sub;

    {
        long multiplikator1;
        long multiplikator2;

    }mul;
    {
        long divisor1;
        long divisor2;
    }div;

Leider mache ich dort was Falsch, aber was genau???

yummi2k10 schrieb:

Danke Jung hat jetzt soweit hingehauen, möchte nun als übung ein Taschenrechner mit Structs und Pointern programmieren.
Dachte ersteinmal an unterstrukturen:
struct rechnervar
{
    {
        long summand1;
        long summand2;
    }add;

    {
        long minuent1;
        long minuent2;
    }sub;

    {
        long multiplikator1;
        long multiplikator2;

    }mul;
    {
        long divisor1;
        long divisor2;
    }div;
Leider mache ich dort was Falsch, aber was genau???

Der ganze Ansatz scheint mir falsch zu sein. Wozu soll das gut sein?

Aber vielleicht meinst du das ja so?

struct rechnervar
{
  struct add 
    {
        long summand1;
        long summand2;
    };

  struct sub 
    {
        long minuent1;
        long minuent2;
    };

  struct mul 
    {
        long multiplikator1;
        long multiplikator2;
    };

  struct div
    {
        long divisor1;
        long divisor2;
    };
};

SeppJ

Meinst du dies?

union rechnervar
{
  struct {
    long summand1;
    long summand2;
  }add;

  struct {
    long minuent1;
    long minuent2;
  }sub;

  struct {
    long multiplikator1;
    long multiplikator2;
  }mul;

  struct {
    long divisor1;
    long divisor2;
  }div; 
};

Danke, nun will ich über den Pointer die unterstrukturen ansprechen:

#include <iostream>
using namespace std;

struct rechner
{

  struct add
    {
        long summand1;
        long summand2;
        long loesung;
    };

  struct sub
    {
        long minuent1;
        long minuent2;
        long loesung;
    };

  struct mul
    {
        long multiplikator1;
        long multiplikator2;
        long loesung;
    };

  struct div
    {
        long divisor1;
        long divisor2;
        long loesung;
    };

};

void addition(struct rechner *add);
void subtraktion(struct rechner *sub);
void multiplikation(struct rechner *mul);
void division(struct rechner *div);

int main()
{
    int variante;
    struct rechner variablen;
    struct rechner *ptr;
    ptr=&variablen;

    cout<<"1->Addition 2->Subtraktion 3->Multiplikator 4->Division: ";

    cin>>variante;
    switch(variante)
    {
            case 1:
                addition(ptr);
                break;
            case 2:
                subtraktion(ptr);
                break;
            case 3:
                multiplikation(ptr);
                break;
             case 4:
                 division(ptr);
                 break;
    }

}

void addition(struct rechner *add)
{
    cout<<"Erster Multiplikator: ";
    cin>add.add->summand1;
    cout<<endl<<"Zweiter Multiplikator: ";
}

void subtraktion(struct rechner *sub)
{

}
void multiplikation(struct rechner *mul)
{

}
void division(struct rechner *div)
{

}

cin>add.add->summand1; so klappt dass leider nicht, wie lautet der richtige Syntax?

fr33g

Steck die Klassendefinition oder Strukturdefinition immer in ne Header-Datei und die Implementierung in ne Source-Datei.

Deine Funktionen vom ersten Programm ( also eingabe und ausgabe ) würde ich auch in
Header-Dateien( Funktionsdeklaration ) und Source-Dateien( Funktionsdefinition ) stecken.

EDIT:
Bei deinem Taschenrechner gilt das natürlich auch, also für die Funktionen Addition und so weiter;-)

Gruß freeG

SeppJ

yummiyummi schrieb:

cin>add.add->summand1; so klappt dass leider nicht, wie lautet der richtige Syntax?

cin>>add->add.summand1;

Aber das ganze Design macht nicht einen Hauch von Sinn.

Ist nun auch erstmal um ein bisschen die Syntax zu üben, denn bin vor ner Stunde vom prodezualen C zu C++ umgestiegen.

SeppJ

yummuyummi schrieb:

Ist nun auch erstmal um ein bisschen die Syntax zu üben, denn bin vor ner Stunde vom prodezualen C zu C++ umgestiegen.

Aber wäre es gerade dann nicht sinnvoll, objektorientiertes Design zu üben? Die Syntax von C und C++ ist schließlich quasi identisch. Das Ansprechen von Structs, Arrays und Pointern (wonach du hier gefragt hast) gibt es schließlich auch in C genauso. Bloß, dass du in C++ äußerst selten Pointer und Arrays brauchst - du brauchst sie hier bloß wegen deines komischen Designs.

In der Klausur wird aber genau das drann kommen :S

cin>add.add->summand1;

kannst du mir denn helfen und sagen wie ich nun summand1 anspreche ?

Das hier ist auch noch nicht so schön, aber nur damit du mal siehst, wie viel Code du dir eigentlich sparen kannst:

#include <iostream>

struct Result
{
	long zahl1;
	long zahl2;
};

Result liesZahlen();
long rechnen(Result res, char op);

int main()
{
	while (true)
	{
		int eingabe;

		do
		{
			std::cout << "--- Rechner ---" << std::endl;
			std::cout << "1. Add\n2. Sub\n3. Mul\n4. Div\n5. End\n\nEingabe: ";
			std::cin >> eingabe;
		} while (eingabe < 1 || eingabe > 5);

		switch (eingabe)
		{
			case 1:
				std::cout << rechnen(liesZahlen(), '+') << std::endl;
				break;

			case 2:
				std::cout << rechnen(liesZahlen(), '-') << std::endl;
				break;

			case 3:
				std::cout << rechnen(liesZahlen(), '*') << std::endl;
				break;

			case 4:
				std::cout << rechnen(liesZahlen(), '/') << std::endl;
				break;

			case 5:
				return 0;
		}
	}
}

Result liesZahlen()
{
	Result res;

	std::cout << "\n--- Eingabe ---\n";

	std::cout << "Zahl 1: ";
	std::cin >> res.zahl1;

	std::cout << "Zahl 2: ";
	std::cin >> res.zahl2;

	return res;
}

long rechnen(Result res, char op)
{
	long r = res.zahl1;

	switch (op)
	{
		case '+':
			r += res.zahl2;
			break;

		case '-':
			r -= res.zahl2;
			break;

		case '*':
			r *= res.zahl2;
			break;

		case '/':
			r /= res.zahl2;
			break;
	}

	return r;
}

SeppJ

ymmmmmymym schrieb:

In der Klausur wird aber genau das drann kommen :S

cin>add.add->summand1;

kannst du mir denn helfen und sagen wie ich nun summand1 anspreche ?

Du hast deine Antwort schon, guck mal weiter oben im Thread.

SeppJ:

leider sagt mein compiler dann:

main.cpp:81: error: invalid use of ‘struct rechner::add’