3. liste speicher reservieren und wieder freigeben

liste speicher reservieren und wieder freigeben

  • A

    gut gut, dann mach ich mal die klasse hehe
    bis dennsen - danke fuer die schnelle antwort!

    0
  • A

    ok hier mein resultat:

    lines.ih

    #include "lines.h"

using namespace std;

    lines.h

    #ifndef _INCLUDED_LINES_
#define _INCLUDED_LINES_

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

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

class Lines
{   
   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 sort(Type t);

    private:
        void read();
        void unsort();
};

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

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

#endif

    lines1.cc (std konstruktor)

    #include "lines.ih"

Lines::Lines()
//:
{
   d_elementIdx = 0;
   d_empty = "";
   read();
}

    read.cc

    #include "lines.ih"

void Lines::read()
{
    string line;
    while (getline(cin, line))
    {
       //make a pair out of the inserted line and
       //the generated index and insert it to the vector
       d_allLines.push_back (make_pair (d_elementIdx++, line));
    }
}

    sort.cc

    #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);
}

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

void Lines::sort(Type type) 
{
    if (type == ORIGINAL)
        unsort();
    else
    	sort (d_allLines.begin(), d_allLines.end(), call[type]);
}

    unsort.cc

    #include "lines.ih"

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

void Lines::unsort() 
{	
    sort (d_allLines.begin(), d_allLines.end(), original);
}

    set.cc

    #include "lines.ih"

void Lines::set(size_t idx, std::string const &str)
{
	//check all elements from the beginning to the 
	//end if the element id equals the idx if found
	//change the stored string at this position
    for (size_t i = 0; i < d_allLines.size(); ++i)
    {
      if(d_allLines.at(i).first == idx)
      		d_allLines.at(i).second = str;
    }
}

    versuchte gerade zu kompilieren, bekomme aber schon einen fehler bei der klasse an sich (lines.h).

    [quote]...es ist verboten einen vector ohne typ zu deklarieren[code]

    kA was das sein soll, gebe ja den typ vom typdef an - was mache ich falsch?

    muss jetzt mal weg bin dann am abend zurueck...

    bin auch fuer hinweise zu den diversen funktionen dankbar, was ist nicht gut implementiert usw.

    danke!

    0
  • N

    Inkludier mal <utility> für std::pair ...

    Einige Dinge, die mir noch aufgefallen sind:

    • Das mit dem Header "lines.ih" und using namespace std; würde ich nicht so machen. Ich selber schreibe std:: meistens bei jedem Bezeichner davor. Aber wenn du darauf verzichten willst, kannst du den Namensraum auch in der Implementierungsdatei (bzw. den Dateien) bekannt machen.
    • Soviele Implementierungsdateien halte ich für unnötig. Es ist nicht selten der Fall, dass eine Datei ein wenig länger wird. Aber dann brauchst du auch keinen "Zwischenheader". Und wenn jeder Header mehrere Implementierungsdateien erhält, hat man sehr schnell sehr viele Dateien, die man nicht mehr genau zuordnen kann.
    • Das Funktionszeiger-Array hat bei dir die Signatur int (const Elements, const Elements) . Sollte diese nicht bool (const Elements&, const Elements&) sein?
    • Wieso behandelst du unsort() als Spezialfall? Du könntest die Funktion doch auch als Zeiger in call speichern.
    • Sei vielleicht ein wenig konsistenter mit den Grössentypen. Manchmal verwendest du int , manchmal unsigned int und zum Teil size_t .
    0
  • A

    Inkludier mal <utility> für std::pair ...
    hat nichts gebracht 😞
    wundert mich auch, denn wie ich das ganze in nem anderenprogram (ohne klasse) getestet habe hat es funktioniert...

    Das mit dem Header "lines.ih" und using namespace std; würde ich nicht so machen. Ich selber schreibe std:: meistens bei jedem Bezeichner davor. Aber wenn du darauf verzichten willst, kannst du den Namensraum auch in der Implementierungsdatei (bzw. den Dateien) bekannt machen.

    unser prof macht das so, habs einfach uebernommen 😉

    Soviele Implementierungsdateien halte ich für unnötig. Es ist nicht selten der Fall, dass eine Datei ein wenig länger wird. Aber dann brauchst du auch keinen "Zwischenheader". Und wenn jeder Header mehrere Implementierungsdateien erhält, hat man sehr schnell sehr viele Dateien, die man nicht mehr genau zuordnen kann.

    verstehe nicht ganze was du meinst sorry 🙂

    Das Funktionszeiger-Array hat bei dir die Signatur int (const Elements, const Elements) . Sollte diese nicht bool (const Elements&, const Elements&) sein?

    mein fehler, waere ich dann vermutlich beim weiteren kompliieren drauf gekommen (wollte zuerst ein mal die klasse fertig bekommen)

    Wieso behandelst du unsort() als Spezialfall? Du könntest die Funktion doch auch als Zeiger in call speichern.

    stimmt mache ich 🙂

    Sei vielleicht ein wenig konsistenter mit den Grössentypen. Manchmal verwendest du int , manchmal unsigned int und zum Teil size_t .[/list]

    jop mach ich auch sorry habs nur schnell mal geschrieben...

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

    danke euch!!

    0
  • A

    hier die fehlermeldungen:

    lines.h:13: error: ISO C++ forbids declaration of vector' with no type lines.h:13: error: expected;' before '<' token
    lines.h: In member function size_t Lines::size() const': lines.h:40: error:d_allLines' undeclared (first use this function)
    lines.h:40: error: (Each undeclared identifier is reported only once for each function it appears in.)
    lines.h: In member function const std::string& Lines::at(unsigned int) const': lines.h:45: error:d_allLines' undeclared (first use this function)

    weiß nicht warum, hab zum spaß mal den typ auf int geandert, also:

    vector<int> d_allLines;

    statt

    vector<Elements > d_allLines;

    gleicher fehler - was mache ich falsch? 🙂

    0
  • N

    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 ...

    0
  • A

    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!!!

    0
  • A

    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...

    0
  • J
     

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

    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...

    0
  • N

    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... 😉

    0
  • A

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

    0
  • Administrator

    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

    0
  • A

    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;
    0
  • Administrator

    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

    0
  • A

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

    verstehs ned ganz sorry 🙂

    0
Anmelden zum Antworten