liste speicher reservieren und wieder freigeben

Nexus

AbsoluterBeginner schrieb:

unser prof macht das so, habs einfach uebernommen

Nicht gut. Als Programmierer solltest du selber denken.

AbsoluterBeginner schrieb:

verstehe nicht ganze was du meinst sorry

Du hast fünf (!) Implementierungsdateien (.cc-Dateien), die einem einzigen Header zugeordnet sind.

AbsoluterBeginner schrieb:

wenn mir jemand mit meinem vector problem helfen koennnte waere es super, schaffe es nicht die klasse zu kompilieren

vector liegt natürlich im Namensraum std ...

AbsoluterBeginner

ja, hatte schon bei meiner letzten frage jemand der mir gesagt hat ich soll es nicht so machen (5 .cc datein) aber mein prof will es so also muss ich es so machen

danke fuer den std:: tipp, echt zu dumm - was solls

jetzt hab ich mich schon gefreut das alles passt, doch in der letzten datei die ich kompiliere fehler

geht um die sort.cc hier noch ein mal:

#include "lines.ih"

bool ascending(const Elements& left, const Elements& right)
{
return left.second < right.second;
}

bool descending(const Elements& left, const Elements& right)
{
return -ascending(left, right);
}

bool original(const Elements& left, const Elements& right)
{ //check the first element of the pair (the generated index)
return left.first < right.first;
}

//only three functions have to be implemented at the moment
bool (*call[])(const Elements&, const Elements&) =
{
original,
ascending,
descending,
0,
0,
};

void Lines::sort(Type type)
{
sort (d_allLines.begin(), d_allLines.end(), call[type]);
}

folgende fehlermeldung:

20:37 thomas:~/c++/set3/17/lines g++ -Wall -c sort.cc
sort.cc: In member function void Lines::sort(Lines::Type)': sort.cc:31: error: no matching function for call toLines::sort(__gnu_cxx::__normal_iterator<Elements*, std::vector<Elements, std::allocator<Elements> > >, __gnu_cxx::__normal_iterator<Elements*, std::vector<Elements, std::allocator<Elements> > >, bool (*&)(const Elements&, const Elements&))'
sort.cc:30: note: candidates are: void Lines::sort(Lines::Type)

leider werde ich nicht schlau daraus
bin mir nicht sicher ob ich dass mit pointern zu funktionen richtig verstanden habe. ich behandle dieses codestueck:

bool (*call[])(const Elements&, const Elements&) =
{
original,
ascending,
descending,
0,
0,
};

hier definiere ich doch ein array mit pointern zu funktionene. das array heiss call. der rueckgabe typ der funktionen ist bool und die funktionene erwarten als argumente zwei elemente (vom typ pair<size_t, string>)
mit call[0] rufe ich original aus, call[1] = asc, call[2] = desc.
rest noch nicht implementiert.
falls nicht richtig bitte korigieren

danke!!!

AbsoluterBeginner

hab es geschafft, das problem war dass beide funktionen sort geheissen haben...

alles laess ich kompilieren - sehr gut
nur testen laesst es sich noch nicht wie gewuncht, hier mein code:

#include "lines.ih"

int main()
{
   Lines line;

   cout << "Number o flines read: " << line.size() << endl;

   for(size_t i = 0; i < line.size(); ++i)
   		cout << line.at(i) << endl;

   //  line.sortLines(ASCENDING);  HIER MEIN PROBLEM
   cout << "Absteigend:\n";
   for(size_t i = 0; i < line.size(); ++i)
   		cout << line.at(i) << endl;

   cout << "\nENDE" << endl;
   return 0;
}

nochmal die klasse selbst:

#ifndef _INCLUDED_LINES_
#define _INCLUDED_LINES_

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

typedef std::pair<size_t, std::string> Elements;

class Lines
{
   std::vector<Elements > d_allLines;
   size_t d_elementIdx;
   std::string d_empty;

    public:
        enum Type
        {
            ORIGINAL,
            ASCENDING,
            DESCENDING,
            CASE_ASCENDING,
            CASE_DESCENDING,
        };

        Lines();
        ~Lines();
        size_t size() const;
        void set(size_t idx, std::string const &str);
        std::string const &at(size_t idx) const;
        void sortLines(Type type);

    private:
        void read();
};

inline size_t Lines::size() const
{
    return d_allLines.size();
}

inline std::string const &Lines::at(size_t idx) const
{
    return idx < d_allLines.size() ? d_allLines.at(idx).second : d_empty;
}

#endif

wie uebergebe ich die art der sortierung, habe in der klasse eine public enum, nur schaff es nicht diese zu verwenden

kann mir da jemand helfen?

danke...

jencas

line.sortLines(Lines::ASCENDING);  // HIER WAR DEIN PROBLEM

AbsoluterBeginner

hmm was macht das :: genau??
leuchtet mir nicht ganz ein, dachte irgendwie dass das Typ (name vom enum) vorkommen muesste...

und ein problem habe ich mit dem verkehrt sortieren:
habe die funktionen folgendermassen implementiert:

bool ascending(const Elements& left, const Elements& right)
{  //sort the lines ascending
   return left.second < right.second;
}

bool descending(const Elements& left, const Elements& right)
{  //sort the lines descending (inverted result from ascending)
   return -ascending(left, right);

}

hat nicht funktioniert, also habe ich es geaendert:

bool ascending(const Elements& left, const Elements& right)
{  //sort the lines ascending
   return left.second < right.second;
}

bool descending(const Elements& left, const Elements& right)
{  //sort the lines descending 
   return left.second > right.second;
}

so funktioniert es, ich verstehe aber nicht warum nicht auch die vorherige methode funktioniert...

Nexus

AbsoluterBeginner schrieb:

so funktioniert es, ich verstehe aber nicht warum nicht auch die vorherige methode funktioniert...

Wie sieht der logische Negations-Operator aus? Nein, - ist es nicht...

AbsoluterBeginner

hehe stimmt, bool sollte man schon mit ! negieren
danke!!
nur noch die frage bezgl. der enum offen

Dravere

AbsoluterBeginner schrieb:

hmm was macht das :: genau??
leuchtet mir nicht ganz ein, dachte irgendwie dass das Typ (name vom enum) vorkommen muesste...

Man kann damit auf verschiedene Scopes zugreifen. Lines::ASCENDING sagt dem Kompiler, dass er ASCENDING im Scope der Klasse Lines suchen soll, sonst weiss dieser nicht, was ASCENDING ist.

Grüssli

AbsoluterBeginner

aha also so wie namespace std zum beispiel?

und da der typ in der klasse public ist kann ich daruaf zugreifen ohne ein element davon zu erzeugen?!
das hat mich ein bisschen verwundert, denn normal mache ich ja von einer enum ein objekt (weiß nicht ob man hier objekt oder variable oder wwi sagt :D) welchem ich dann die verfuegbaren werte geben kann.

bp:

enum FARBE
{
  ROT,
  GELB,
  GRUEN
};

FARBE bla;

bla = ROT;

Dravere

AbsoluterBeginner schrieb:

aha also so wie namespace std zum beispiel?
und da der typ in der klasse public ist kann ich daruaf zugreifen ohne ein element davon zu erzeugen?!

Genau.
Das ist wie mit statischen Funktionen oder Variablen, die werden auch so aufgerufen. Oder Typen in der Klasse, seien sie nun enums, structs, classes oder simple typedefs.

AbsoluterBeginner schrieb:

das hat mich ein bisschen verwundert, denn normal mache ich ja von einer enum ein objekt (weiß nicht ob man hier objekt oder variable oder wwi sagt :D) welchem ich dann die verfuegbaren werte geben kann.

Ehm, ich ändere mal dein Beispiel etwas:

enum Type
{
  ORIGINAL,
  ASCENDING,
  DESCENDING,
  CASE_ASCENDING,
  CASE_DESCENDING,
};

// ...

Type type; // <- Objekt erzeugen

type = Type::ASCENDING; // <- ASCENDING muss hier nicht erzeugt werden,
                        //    der Wert existiert bereits.

Du übergibst ja die konstante ASCENDING , was im Funktionsparameter-Objekt vom Typ enum Type gespeichert wird.

Grüssli

AbsoluterBeginner

hmm, du meinst der ganze code jetzt ausserhalb der klasse, also in meinem programm mit dem ich die klasse teste?

verstehs ned ganz sorry