hab folgende Schulaufgabe (ist eine Abschrift der Abgabe beim Lehrer, das original hab ich leider nicht mehr :/) geschrieben - ich bin mir zu 100% sicher, dass sie sich einwandfrei kompilieren ließ, zu dem Zeitpunkt, als ich Sie abgegeben hab (habe in den letzten 5 Minuten das billige Menü hingezimmert und mir nach dem kompilieren angesehen).

Scheinend hat der Compiler vom Lehrer irgendetwas verändert - z.b. ist es nicht meine Art, die { in die nächste Zeile zu tippen, sondern hinten dran - trotzdem kommt das häufig vor, und ich war's definitiv nicht.

Er meckert immer, er würde ein ; oder { erwarten - auf Höhe von " class fass:public bier() {" - ich hab keinen Fehler gefunden. Jemand eine Idee??

#include <iostream>
#include <iomanip>
#include <string>
#include <conio.h>

using namespace std;

class bier {
    private: 
        string sorte;
        int menge;
    public:
        bier(string n_sorte, int s_menge) {
            sorte = n_sorte;
            menge = s_menge;
        }
        bier() {}

        int getmenge();
        void setmenge(int);
        void anzeige();
    };

    class kasten:public bier {
        private:
            int anzahl_Flaschen;
            float Flaschenvolumen;
        public:
            float getflaschenvolumen();
            int getanzahlflaschen();

             kasten(int n_anzahl_Flaschen, float n_Flaschenvolumen) {
                if( n_anzahl_Flaschen == 11 || n_anzahl_Flaschen == 20 ) {
                    if (n_Flaschenvolumen != 0.5) {
                        cout << "Fehler! ... " << n_Flaschenvolumen << "§passt nicht überein" << anzahl_Flaschen;
                    } else {
                        anzahl_Flaschen = n_anzahl_Flaschen;
                        Flaschenvolumen = n_Flaschenvolumen;
                    }
                }

                if( n_anzahl_Flaschen == 24) {
                    if (n_Flaschenvolumen != 0.33) {
                        cout << "Fehler! ... " << n_Flaschenvolumen << " Flascheanzahl " << n_anzahl_Flaschen << "überein!";
                    } else  {
                        anzahl_Flaschen = n_anzahl_Flaschen;
                        Flaschenvolumen = n_Flaschenvolumen;
                    }
                }
            } 

            kasten() {}
            void anzeige();
        };

        class fass:public bier() {
            private:
                float preis_pro_liter;
                int fassvermoegen;
            public:
               /* fass(float n_preis_pro_liter, int n_fassvermoegen) {
                    if( n_fassvermoegen == 11 || n_fassvermoegen == 15 || n_fassvermoegen == 30 || n_fassvermoegen == 50) {
                        fassvermoegen = n_fassvermoegen;
                    } else {
                        cout << "Fassvermoegen muss wert...";
                    }
                    if (n_preis_pro_liter <= 0) {
                        cout << "preiss...";
                    } else {
                        preis_pro_liter = n_preis_pro_liter;
                    }
                }

                */

                bool fuellen(int);
                void anzeige();
                int getpreisproliter();
                int getfassvermoegen();
            };

            int bier::getmenge() {
                return menge;
            }

            void bier::setmenge(int s_menge) {
                menge = s_menge;
            }

            int kasten::getanzahlflaschen() {
                return anzahl_Flaschen;
            }

            float kasten::getflaschenvolumen() {
                return Flaschenvolumen;
            }

            void bier::anzeige() {
                cout << "Biersorte: " << sorte << endl;
                cout << "Menge: " << getmenge() << " hl" << endl;
            }

            void kasten::anzeige() {
                bier::anzeige();
                cout << "Flaschenanzahl: " << getanzahlflaschen() << endl;
                cout << "Flaschenvolumen: " << getflaschenvolumen() << endl;
            }

            int fass::getfassvermoegen() {
                return fassvermoegen;
            }

            int fass::getpreisproliter() {
                return preis_pro_liter;
            }

            void fass:anzeige() {
                bier::anzeige();
                cout << getfassvermoegen();
                cout << getpreisproliter();
                cout << getfassvermoegen*getpreisproliter();
            }

            void main() {
                int x = 1, auswahl, temp;
                bier pils("Pils", 50);
                kasten kunde1(20, 0.5);
                fass gross(3,11);

                gross.anzeige();
                while ( x == 1 ) {
                    cout << "Anzeige kasten 1";
                    cin >> auswahl;
                    if ( auswahl == 1) {
                        kunde1.anzeige();
                    }
                    if( auswahl == 2 ) {
                        gross.anzeige();
                    }
                    if( auswahl == 3) {
                        cout << "Vermoegen?" << endl;
                        cin >> temp;
                        gross.fuellen(temp);
                    }
                    if( auswahl == 0 ) {
                        x = 0;
                    }
                }
                getch();
            }

Die Schriftausgaben sind stark verkürzt - das Script ist aber definitiv eine exakte Abschrift vom Ausdruck des Lehrers - und es läuft nicht Und ich will wissen warum!

Kann die IDE des Lehrers, wenn diese eine andere ist, ggf. im Code rumpfuschen - weil Sie Syntaxanpassungen o.ä. macht? Handelt sich wohl um Microsoft Visual C++...

class fass:public bier() { ... }

die Klammern () müssen weg.

Es kann sein, dass dein lehrer was am code gemacht hat (aber solche klammern setzt keine ide irgendwo automatisch hin.). Warum nimmst du denn nciht deinen code sondern den vom lehrer?

int main()

und nicht

void main()

#if !defined (BEER_HPP__INCLUDED)
#define BEER_HPP__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include "bottle.hpp"
#include <string>

class beer : public bottle
{
	beer(std::string const& name, const double content)
		: bottle(name, content)
	{
		if (content != 0.5 && content != 0.33) throw std::invalid_argument("invalid beer size");
	}
};

#endif // BEER_HPP__INCLUDED

#if !defined(CRATE_HPP__INCLUDED)
#define CRATE_HPP__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <vector>
#include <iostream>
#include "bottle.hpp"

class crate
{
	std::vector<bottle*> m_bottles;
	const std::size_t m_size;
	const double m_bottlesize;

public:
	crate(const std::size_t size, const double bottlesize)
		: m_size(size), m_bottlesize(bottlesize)
	{}

	friend std::ostream& operator << (std::ostream& out, crate const& data)
	{ return out << "Kasten (" << data.m_size << " Flaschen) mit einem Volumen von " << m_size * m_bottlesize << "L"; }

public:
	void insert_bottle(const bottle* item)
	{
		if (item->get_content() > m_bottlesize) throw std::invalid_argument("bottle does not match");
		if (m_bottles.size() > m_size) throw std::runtime_error("crate already full");
		m_bottles.push_back(item);
	}
};

#endif // CRATE_HPP__INCLUDED

#include "crate.hpp"
#include <vector>
#include <algorithm> // std::copy
#include <iterator>
#include <iostream>

int main() 
{
	std::vector<crate> m_store(10, crate(10, 0.5));
	std::copy(m_store.begin(), m_store.end(), std::ostream_operator<crate>(std::cout, "\n"));
}

Fertig