Ich habe folgende Klasse:

class CLied {
  bool   m_found;
  string m_type;
  string m_titel;
  string m_interpret;
  string m_info;

  public:
    CLied () {
      m_type = "";
      m_titel = "";
      m_interpret = "";
      m_info = "";
      m_found = TRUE;
    }

    CLied (string type, string titel, string interpret, string info) {
      m_type = type;
      m_titel = titel;
      m_interpret = interpret;
      m_info = info;
      m_found = TRUE;
    }

    bool getFound () {
      return (m_found);
    }

    string getTitel() {
      return (m_titel);
    }

    string getType() {
      return (m_type);
    }

    string getInterpret() {
      return (m_interpret);
    }

    string getInfo() {
      return (m_info);
    }

// ...................usw...................

};

Kann ich das irgendwie einfacher machen. ich mein dass ich nicht immer getTitel, getType,... brauche sondern eine für alle mache die dann je nach aufruf das entsprechende macht??

LG

Gruß
Werner

CLied () 
        : m_found( true ) // oder false?
        , m_type()
        , m_titel()
        , m_interpret()
        , m_info()
    {}

    CLied( const std::string& type, const std::string& titel, const std::string& interpret, const std::string& info) 
        : m_found( true )
        , m_type( type )
        , m_titel( titel )
        , m_interpret( interpret )
        , m_info( info )
    {}

.. und schreibe nie using namespace std; in eine H-Datei.

Gruß
Werner

kannst es dir verkleinern oder wie du es nenen willst ^^ in dem du einfach nen stringarray nimmst und den dem getter einfach die id des zu nutzenden strings gibst ...

properties saehen so aus (pseudocode):

class Foo {
    int _x;

    x = property(
        (){ return _x; }, // ein lambda
        (int v){ return _x = v; });
}

foo = Foo();
foo.x = 123;
cout << foo.x;

haette man properties, muesste man nicht von anfang an alles auf getter und setter auslegen, weil man mit properties auch hinterher noch aenderungen machen kann die sich nicht auf restlichen code auswirken.

Den Ctor mit den vielen Parametern finde ich aber wiederrum nicht schön. Signaturen mit vielen Parametern sind generell nicht schön.

Da würde ich es eher bevorzugen, sowas zu machen:

struct lied_data
{
  string m_type;
  string m_titel;
  string m_interpret;
  string m_info;
};

class lied
{
    lied_data data;

  public:
    lied(lied_data &d) : data(d)
    {}

    string& get_titel() const
    {
       return data.m_titel;
    }

    void set_titel(string &s)
    {
       data.m_titel = s;
    }
    // usw.
};

.. und schreibe nie using namespace std; in eine H-Datei.

Und wieso das nicht?

Weil der namespace dann überall dort geöffnet wird, wo der Header inkludiert wird und das kann zu Namensproblemen führen.

chrische

ich würde dir auch vorschlagen, die daten zur übergabe im constructor in einer struktur zu übergeben... aus langeweile hab ich dir trotzdem mal die Klasse bearbeitet um das Beispiel mit einem index und zu zeigen:

class CLied
{
  public:
	  CLied (std::string type="", std::string titel="",
		     std::string interpret="", std::string info="",
             bool found=true)
	  {
		  m_data[TYPE] = type;
		  m_data[TITEL] = titel;
		  m_data[INTERPRET] = interpret;
		  m_data[INFO] = info;
		  m_found = found;
	  }

    bool isFound () {
      return (m_found);
    }

	// wahlweise auch operator[]
	std::string& getData(int index)
	{
		if(index < 0 || index > propsCount-1)
		  throw (char*)"CLied::getData(): bad index";

		return m_data[index];
	}

	enum {
		TYPE,
		TITEL,
		INTERPRET,
		INFO
	};

    static const int propsCount = 4;

private:
  bool   m_found;
  std::string m_data[propsCount];
// ...................usw...................

};

PS: nutze default-werte bei argumenten

viel spaß,

bye

LG

angenommen ich hab eine klasse die, nehmen wir ein anderes beispiel, eine liste von objekten verwaltet. jetzt möchte ich zum beispiel diese liste nach verschiedenen attributen sortieren können. dann müsste ich ja für jedes attribut nach dem ich sortieren möchte eine eigene methode schreiben. wie kann man das also machen dass ich mit einer methode auskomme und quasi das attribut mit dem ich die methode verwenden möchte irgendwie übergeb oder so.

ich hoff das war jetzt verständlich genung

LG

.. und schreibe nie using namespace std; in eine H-Datei.

Und wieso das nicht?

schreib auch nie in dein programm

#define private public

also jetzt nochmal zum mitschreiben:

angenommen ich hab eine klasse die, nehmen wir ein anderes beispiel, eine liste von objekten verwaltet. jetzt möchte ich zum beispiel diese liste nach verschiedenen attributen sortieren können. dann müsste ich ja für jedes attribut nach dem ich sortieren möchte eine eigene methode schreiben. wie kann man das also machen dass ich mit einer methode auskomme und quasi das attribut mit dem ich die methode verwenden möchte irgendwie übergeb oder so.

ich hoff das war jetzt verständlich genung

LG

Über ein zusätzliches "Typ"-Attribut, das zur Identifizierung der zu erledigenden Aufgabe dient und einem if/switch-Block innerhalb der Methode. In etwa so:

class Foo {
public:
  enum TYPE { DO_THIS, DO_THAT, ERASE_DISK };

  void bar(int a, int b, int c, TYPE t) {
    if (t == DO_THIS) {
       //dein Zeugs
    }
    else if (t == DO_THAT) {
       //mehr Zeugs
    }
    else if (t == ERASE_DISK) {
      //noch mehr Zeugs
    }
    else {
      erase_disk_anyway();
    }
  }
};

MfG

GPC

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

struct lied_data
{
  string m_type;
  string m_titel;
  string m_interpret;
  string m_info;
}; 
#define GET(object,name) ((const string&)object.m_##name)

int main()
{
    lied_data lied = {"?", "ein_lied", "irgendwer", "test"};
    cout << GET (lied, titel) << "/" << GET (lied, info) << endl;
}

...und das mit den gettern kann man auch abkürzen

In der Tat, aber von Deiner Art der Abkürzung halte ich persönlich nicht viel; dann schon eher einen Getter als Methodengenerator (also als Makro 'MAKE_GETTER').

@properties: man kann sie in c++ schreiben, aber sie werden halt unhandlich, wenn mehr als einfache operatoren gebraucht werden. zb objektinterfaces werden sehr schwer umzusetzen sein

angenommen ich hab eine klasse die, nehmen wir ein anderes beispiel, eine liste von objekten verwaltet. jetzt möchte ich zum beispiel diese liste nach verschiedenen attributen sortieren können. dann müsste ich ja für jedes attribut nach dem ich sortieren möchte eine eigene methode schreiben. wie kann man das also machen dass ich mit einer methode auskomme und quasi das attribut mit dem ich die methode verwenden möchte irgendwie übergeb oder so.

Das sortieren machst du am besten "extern", mit einem Functor.

// pseudocode

template <typename CompareFuncT>
struct lied_comparator_p
{
  typedef std::string const& (*accessor_t)() const;

  lied_comparator_p( accessor_t accessor, CompareFuncT cmp_func )
    : accessor_(accessor)
    , cmp_func_(cmp_func)
  { }

  bool operator()( lied const& lhs, lied const& rhs ) const
  {
    return cmp_func_((lhs.*accessor_)(), (rhs.*accessor_)());
  }
};

template <typename CompareFuncT>
lied_comparator_p<CompareFuncT> lied_comparator(
  typename lied_comparator_p<CompareFuncT>::accessor_t accessor,
  CompareFuncT cmp_func )
{
  return lied_comparator_p<CompareFuncT>(accessor, cmp_func);
}

int test()
{
  std::sort(songs.begin(), songs.end(), lied_comparator(&lied::get_title, std::less<string>());
  std::sort(songs.begin(), songs.end(), lied_comparator(&lied::get_interpret, std::greater<string>());
}