also ich habe shcon ma so einen ähnlichen thread aber der ist net vollständig,.

mein problem ist folgendes ,mein Programm ist jetzt, (zumindest denke ich das) soweit fertig, also ich meine main.cpp kompilieren wollte, kamen aber 2 fehler die mir net so ganz klar sind. vieleicht könnt ihr mir auf die sprünge helfen.

C:\Dokumente und Einstellungen\christopher\Desktop\Programme\C++\Mengen\main.o:main.cpp:(.text+0x104f):: undefined reference to Menge::getmax(std::vector<int, std::allocator<int> >)' C:\\Dokumente und Einstellungen\\christopher\\Desktop\\Programme\\C++\\Mengen\\main.o:main.cpp:(.text+0x10d0):: undefined reference toMenge::getmin(std::vector<int, std::allocator<int> >)'
:: === Build finished: 2 errors, 0 warnings ===

so hier ist meine headerdatei

Class_menge.h

#ifndef CLASS_MENGE_H_INCLUDED
#define CLASS_MENGE_H_INCLUDED
#include<vector>

using namespace std;
class Menge
{
    public:
    void hinzufuegen(int el);                  //Fügt Elemente in den Vector ein.

    void entfernen(int el);                    //Entfernt Elemente in der Liste.

    bool istvorhanden(int el);                 //Prüft ob ein Element schon vorhanden ist.

    void size();                             //Gibt die Größe der Liste zurück.

    void anzeigen() ;                          // Gibt die Elemente der Liste normal aus.

    void loeschen();                           // Löscht die Liste.

    void getmax(vector<int>Liste);              // Findet das Maximum.

    void getmin(vector<int>Liste);              // Findet das Minimum.

    void sortieren(vector<int>Liste);          // sortiert die Liste nach Bubblesort.

    private:
    vector<int> Liste;                         // Ist für die Speicherung zuständig.

};
#endif // CLASS_MENGE_H_INCLUDED

dann die implementierungen

menge.cpp

#include "Class_menge.h"
#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;
//////////////////////////////////////////////////////////////
bool Menge::istvorhanden(int el)
{
    for(size_t i=0;i<Liste.size();++i)
    {
       if(el==Liste[i])
       {
           cout<<"Diese Zahl ist schon vorhanden"<<endl;
           return true;
       }
       else
       {
           cout<<"Zahl nicht vorhanden kann also noch eingefuegt werden"<<endl;
           return false;
       }
    }
}
//////////////////////////////////////////////////////////////
void Menge::sortieren(vector<int>Liste)
{
    vector<int>sortiert_Liste=Liste;
    for(size_t i=1;i<sortiert_Liste.size();++i)
    {
        for(size_t j=0;j<i;++j)
        {
            if(sortiert_Liste[i]<sortiert_Liste[j])
            {
                int speicher=sortiert_Liste[i];
                sortiert_Liste[i]=sortiert_Liste[j];
                sortiert_Liste[j]=speicher;
            }
        }
    }
    for(size_t i=0;i<Liste.size();++i)
    {
        cout<<"Der Inhalt ist nun: "<<endl;
        cout<<sortiert_Liste[i]<<endl;
    }
}
//////////////////////////////////////////////////////////////////
void Menge::anzeigen()
{
   sortieren(Liste);
}
/////////////////////////////////////////////////////////////////
void Menge::getmax(vector<int>Liste)
{
    vector<int>sortiert_Liste=Liste;
    for(size_t i=1;i<sortiert_Liste.size();++i)
    {
        for(size_t j=0;j<i;++j)
        {
            if(sortiert_Liste[i]<sortiert_Liste[j])
            {
                int speicher=sortiert_Liste[i];
                sortiert_Liste[i]=sortiert_Liste[j];
                sortiert_Liste[j]=speicher;
            }
        }
    }
    int max= Liste[0];

    for(size_t i=0;i<Liste.size();++i)
    {
        if(max<Liste[i])
        {
            max=Liste[i];
        }
    }
    cout<<"Das Maximum ist: "<<max<<endl;
}
/////////////////////////////////////////////////////////////////
void Menge::getmin(vector<int>Liste)
{
    vector<int>sortiert_Liste=Liste;
    for(size_t i=1;i<sortiert_Liste.size();++i)
    {
        for(size_t j=0;j<i;++j)
        {
            if(sortiert_Liste[i]<sortiert_Liste[j])
            {
                int speicher=sortiert_Liste[i];
                sortiert_Liste[i]=sortiert_Liste[j];
                sortiert_Liste[j]=speicher;
            }
        }
    }
    int min= Liste[0];

    for(size_t i=0;i<Liste.size();++i)
    {
        if(min>Liste[i])
        {
            min=Liste[i];
        }
    }
    cout<<"Das Minimum ist: "<<min<<endl;
}
///////////////////////////////////////////////////////////////////
void Menge::size()
{
    int i;
    for( i=0;i<Liste.size();++i)
    {
    }
    cout<<"Die Liste hat"<<i<<" Elemente"<<endl;
}
//////////////////////////////////////////////////////////////////
void Menge::hinzufuegen(int el)
{

    if(istvorhanden(el)==true)
    {
        cout<<"Element wird nicht eingefuegt,da vorhanden"<<endl;
    }
    else if(istvorhanden(el)==false)
    {
    Liste.push_back(el);

    sortieren(Liste);
    }
}
//////////////////////////////////////////////////////////////////
void Menge::entfernen(int el)
{
    if(istvorhanden(el)==true)
    {
        vector<int>::iterator pos=find(Liste.begin(),Liste.end(),el);

        Liste.erase(pos);

    }
    else if(istvorhanden(el)==false)
    {
       cout<<" Element ist nicht vorhanden und muss nicht gelöscht werden"<<endl;
    }

}
/////////////////////////////////////////////////////////////////////
void Menge::loeschen()
{
    Liste.clear();
}

und die main

main.cpp

#include<iostream>
#include<vector>
#include"Class_Menge.h"
#include"menge.cpp"

using namespace std;

void bildschirm()
{

    cout<<"-----------Listenprogramm-----------"<<endl;
    cout<<endl;
    cout<<" 1. Ein Element hinzufuegen"<<endl;
    cout<<" 2. Ein Element entfernen"<<endl;
    cout<<" 3. Ein Element auf vorhandensein pruefen"<<endl;
    cout<<" 4. Die Groesse der Liste anzeigen"<<endl;
    cout<<" 5. Die Liste anzeigen"<<endl;
    cout<<" 6. Die Liste loeschen"<<endl;
    cout<<" 7. Das Maximum anzeigen"<<endl;
    cout<<" 8. Das Minimum anzeigen"<<endl;
    cout<<" 9. Die Liste sortieren"<<endl;
    cout<<" 10. Beenden"<<endl;
    cout<<endl;
    cout<<"------------------------------------"<<endl;
    cout<<endl;
    cout<<"---------Bitte Waehlen Sie----------"<<endl;

}
////////////////////////////////////////////////////////////

int main()
{
    Menge eineMenge;

    int in_Liste,abfrage;

    vector<int>Fuell_Liste;

    bildschirm();

do{
   cin>>abfrage;

   system("CLS");

    switch(abfrage)
    {
        case 1:
        cout<<"Geben sie ein neue Zahl ein"<<endl;
        cout<<endl;
        cin>>in_Liste;
        eineMenge.hinzufuegen(in_Liste);
        break;

        case 2:
        cout<<"Geben sie das zu entfernede Element ein"<<endl;
        cout<<endl;
        cin>>in_Liste;
        eineMenge.entfernen(in_Liste);
        break;

        case 3:
        cout<<"Geben sie das zupruefende Element ein"<<endl;
        cout<<endl;
        cin>>in_Liste;
        eineMenge.istvorhanden(in_Liste);
        break;

        case 4:
        eineMenge.size();
        break;

        case 5:
        eineMenge.anzeigen();
        break;

        case 6:
        cout<<"Liste wird geloescht..."<<endl;
        eineMenge.loeschen();
        break;

        case 7:
        eineMenge.getmax(Fuell_Liste);
        break;

        case 8:
        eineMenge.getmin(Fuell_Liste);
        break;

        case 9:
        cout<<"Liste wird nun sortiert"<<endl;
        eineMenge.sortieren(Fuell_Liste);
        break;

        case 10:
        system("Exit");
    }
}while(abfrage!=10);
}

bitte erstma nicht den code ins lächerliche ziehen, kann sein das man ihn noch optimieren kann,aber ich wollte erstma wissen was der fehler ist der oben bereits geschrieben wurden.

Danke für eure Lesearbeit

Menge::getmin(...)

und

Menge::getmax(...)

anstatt

getmin(...)

und

getmax(...)

Gruß
zeigerzeiger

EDIT: Aah zu spät

do
{
//...
}
while(abfrage != 10)

um dein switch...

Gruß
zeigerzeiger

du springst schließlich bei jedem case aus dem Programm, mach mal statt

return 0;

ein

break;

Gruß
zeigerzeiger

#include<iostream> 
#include<vector> 
#include<algorithm> 

using namespace std; 

class Menge 
{ 
    public: 
    void hinzufuegen(int el);                  //Fügt Elemente in den Vector ein. 

    void entfernen(int el);                    //Entfernt Elemente in der Liste. 

    bool istvorhanden(int el);                 //Prüft ob ein Element schon vorhanden ist. 

    void size();                             //Gibt die Größe der Liste zurück. 

    void anzeigen() ;                          // Gibt die Elemente der Liste normal aus. 

    void loeschen();                           // Löscht die Liste. 

    void getmax(vector<int>Liste);              // Findet das Maximum. 

    void getmin(vector<int>Liste);              // Findet das Minimum. 

    void sortieren(vector<int>Liste);          // sortiert die Liste nach Bubblesort. 

    private: 
    vector<int> Liste;                         // Ist für die Speicherung zuständig. 

};

////////////////////////////////////////////////////////////// 
bool Menge::istvorhanden(int el) 
{ 
    for(size_t i=0;i<Liste.size();++i) 
    { 
       if(el==Liste[i]) 
       { 
           cout<<"Diese Zahl ist schon vorhanden"<<endl; 
           return true; 
       } 
       else 
       { 
           cout<<"Zahl nicht vorhanden kann also noch eingefuegt werden"<<endl; 
           return false; 
       } 
    } 
} 
////////////////////////////////////////////////////////////// 
void Menge::sortieren(vector<int>Liste) 
{ 
    vector<int>sortiert_Liste=Liste; 
    for(size_t i=1;i<sortiert_Liste.size();++i) 
    { 
        for(size_t j=0;j<i;++j) 
        { 
            if(sortiert_Liste[i]<sortiert_Liste[j]) 
            { 
                int speicher=sortiert_Liste[i]; 
                sortiert_Liste[i]=sortiert_Liste[j]; 
                sortiert_Liste[j]=speicher; 
            } 
        } 
    } 
    for(size_t i=0;i<Liste.size();++i) 
    { 
        cout<<"Der Inhalt ist nun: "<<endl; 
        cout<<sortiert_Liste[i]<<endl; 
    } 
} 
////////////////////////////////////////////////////////////////// 
void Menge::anzeigen() 
{ 
   sortieren(Liste); 
} 
///////////////////////////////////////////////////////////////// 
void Menge::getmax(vector<int>Liste) 
{ 
    cout<<"Das Maximum ist: "<<*std::max_element(this->Liste.begin(), Liste.end())<<endl; 
} 
///////////////////////////////////////////////////////////////// 
void Menge::getmin(vector<int>Liste) 
{ 

    cout<<"Das Minimum ist: "<<*std::min_element(this->Liste.begin(), this->Liste.end())<<endl; 
} 
/////////////////////////////////////////////////////////////////// 
void Menge::size() 
{ 
    int i; 
    for( i=0;i<Liste.size();++i) 
    { 
    } 
    cout<<"Die Liste hat"<<i<<" Elemente"<<endl; 
} 
////////////////////////////////////////////////////////////////// 
void Menge::hinzufuegen(int el) 
{ 

    if(istvorhanden(el)==true) 
    { 
        cout<<"Element wird nicht eingefuegt,da vorhanden"<<endl; 
    } 
    else if(istvorhanden(el)==false) 
    { 
    Liste.push_back(el); 

    sortieren(Liste); 
    } 
} 
////////////////////////////////////////////////////////////////// 
void Menge::entfernen(int el) 
{ 
    if(istvorhanden(el)==true) 
    { 
        vector<int>::iterator pos=find(Liste.begin(),Liste.end(),el); 

        Liste.erase(pos); 

    } 
    else if(istvorhanden(el)==false) 
    { 
       cout<<" Element ist nicht vorhanden und muss nicht gelöscht werden"<<endl; 
    } 

} 
///////////////////////////////////////////////////////////////////// 
void Menge::loeschen() 
{ 
    Liste.clear(); 
}

void bildschirm() 
{ 

    cout<<"-----------Listenprogramm-----------"<<endl; 
    cout<<endl; 
    cout<<" 1. Ein Element hinzufuegen"<<endl; 
    cout<<" 2. Ein Element entfernen"<<endl; 
    cout<<" 3. Ein Element auf vorhandensein pruefen"<<endl; 
    cout<<" 4. Die Groesse der Liste anzeigen"<<endl; 
    cout<<" 5. Die Liste anzeigen"<<endl; 
    cout<<" 6. Die Liste loeschen"<<endl; 
    cout<<" 7. Das Maximum anzeigen"<<endl; 
    cout<<" 8. Das Minimum anzeigen"<<endl; 
    cout<<" 9. Die Liste sortieren"<<endl; 
    cout<<" 10. Beenden"<<endl; 
    cout<<endl; 
    cout<<"------------------------------------"<<endl; 
    cout<<endl; 
    cout<<"---------Bitte Waehlen Sie----------"<<endl; 

} 
//////////////////////////////////////////////////////////// 

int main() 
{ 
    Menge eineMenge; 

    int in_Liste = 0,abfrage = 0; 

    vector<int>Fuell_Liste; 

    do
    {
	    bildschirm(); 

	    //system("CLS"); 
	    cin >> abfrage;

	    switch(abfrage) 
	    { 
	        case 1: 
	        cout<<"Geben sie ein neue Zahl ein"<<endl; 
	        cout<<endl; 
	        cin>>in_Liste; 
	        eineMenge.hinzufuegen(in_Liste); 
	        break; 

	        case 2: 
	        cout<<"Geben sie das zu entfernede Element ein"<<endl; 
	        cout<<endl; 
	        cin>>in_Liste; 
	        eineMenge.entfernen(in_Liste); 
	        break; 

	        case 3: 
	        cout<<"Geben sie das zupruefende Element ein"<<endl; 
	        cout<<endl; 
	        cin>>in_Liste; 
	        eineMenge.istvorhanden(in_Liste); 
	        break; 

	        case 4: 
	        eineMenge.size(); 
	        break; 

	        case 5: 
	        eineMenge.anzeigen(); 
	        break; 

	        case 6: 
	        cout<<"Liste wird geloescht..."<<endl; 
	        eineMenge.loeschen(); 
	        break; 

	        case 7: 
	        eineMenge.getmax(Fuell_Liste); 
	        break; 

	        case 8: 
	        eineMenge.getmin(Fuell_Liste); 
	        break; 

	        case 9: 
	        cout<<"Liste wird nun sortiert"<<endl; 
	        eineMenge.sortieren(Fuell_Liste); 
	        break; 

	        case 10:
	        default:
	        break;
	    }
    }
    while(abfrage != 10);

    return 0;
}

Soweit müsste das dann klappen...

Gruß
zeigerzeiger

Sorry leute das ich eure Nerven so strapaziere, is halt mein erstes klassen projekt.Wäre trotzdem über hilfe sehr dankbar

void Menge::anzeigen() 
{ 
   sortieren(Liste); 
}

PS: Was wollen eigentlich die Parameter bei getmax(), getmin() und sortieren() darstellen?

Firefighter schrieb:

naja wennde guckst, siehste ja das eigentlich die methode sortieren,sortiert und dann gleichzeitig anzeig

Da solltest du nochmal die Aufgabenteilung der Methoden überdenken - anzeigen() sollte sich um die Anzeige kümmern und nicht sortieren (dafür ist sortieren() da) und umgekehrt.

naja wennde guckst, siehste ja das eigentlich die methode sortieren,sortiert und dann gleichzeitig anzeig,...

Nur mal so am Rande:
Eine Funktion sollte möglichst eine klar umrissene Aufgabe erledigen. Das macht das Lesen des Codes zum einen leichter, zum anderen ist es spätestens in der Arbeit im Team unabdingbar. Man kann nicht erwarten das sich andere den Sourcecode durchlesen um herauszufinden was die Methode macht (Man entwickelt gegen die Schnittstelle, sprich die Deklaration, nicht die konkrete Implementierung).

cu André

Die Methoden sollten doch eigentlich alle mit dem Member "vector<int> Liste;" arbeiten - also ist es nicht nötig, den zu sortierenden bzw. zu durchsuchenden vector<> nochmal als Parameter mitzugeben.

wie meinste das... meinste damit ich soll aus dem methoden prototypen das

vector<int>Liste

rausnehmen und gar keine wert übergeben?? und dann nur in die Methode reinschreiben ,wenn es zum soriteren kommt, welchen vector er nehmen soll, nämlich den einen der nur unter private vergeben ist.meinste das so??