Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

kiba

Alter Hase

  • »kiba« ist der Autor dieses Themas

Beiträge: 327

Wohnort: NRW

Beruf: Azubi: Fach-Info. Anw.

  • Private Nachricht senden

1

04.11.2009, 15:05

Array und Funktions(pointer)

Hi, hab ein Problem, ich hab eine Funktion die mir ein object speichern soll(die Funktion(ist virtual und) wurde von eine Klasse geerbt)
Jetzt ist das Problem ich hab ein Array(std::vector) mit einer bestimmten Klasse und jenachdem was das für eine Klasse ist werden die Daten eben anders gespeichert.
z.b. durch die Funktion save(von der SubKlasse) oder die normale write Funktion aus der std::ofstream Klasse.

Kann ich nicht irget wie basis Klasse ermitteln um zu schaunen ob die Funktionen da vorhanden ist oder so.

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class FileData{
    protected:
    FileData(){};
    virtual ~FileData(){}

    virtual void save(std::ofstream& output) = 0;
    virtual void load(std::ifstream& input) = 0;

   public:

    template< class T >
    static void saveArray(std::vector<T>& array, std::ofstream& output){
        size_t size = array.size();
        output.write((char*)&size,sizeof(size));
        if(array.size() > 0){
            for(size_t i = 0;i < array.size();i++){
                //if (ist die save Funktion vorhanden)

                //array[i].save(output);

                //else

                output.write((char*)&array[i],sizeof(array[i]));
            }
        }
    }
    
    //das selbe noch mal für die static void loadArray(...) Funktion

};

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

2

04.11.2009, 18:56

Du könntest einfach dafür sorgen, dass nur Objekte in dem Array landen die diese Funktionen implementieren?!

Databyte

Alter Hase

Beiträge: 1 040

Wohnort: Na zu Hause

Beruf: Student (KIT)

  • Private Nachricht senden

3

04.11.2009, 20:14

Und für standard-typen kannste ja einfach ne wrapper-klasse mit template machen.

kiba

Alter Hase

  • »kiba« ist der Autor dieses Themas

Beiträge: 327

Wohnort: NRW

Beruf: Azubi: Fach-Info. Anw.

  • Private Nachricht senden

4

05.11.2009, 13:40

Und wie soll ich das machen ^^ :oops:

5

05.11.2009, 19:24

Zitat von »"kiba"«

Und wie soll ich das machen ^^ :oops:

Ich würde das mit Traits lösen. Das könnte dann zum Beispiel so ausschauen:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <iostream>

//------------------------------------------------------------------------------


struct Test
{
  void save() const
  { std::cout << "Save" << std::endl; }
};

//------------------------------------------------------------------------------


template<typename T>
struct supports_save
{ static const bool value = false; };

// Spezialisierung für Test, da es save unterstützt

template<>
struct supports_save<Test>
{ static const bool value = true; };

//------------------------------------------------------------------------------


template<bool SupportsSave>
struct saver
{
  template<typename T>
  static void doSave( const T& ref );
};

template<bool SupportsSave>
template<typename T>
void saver<SupportsSave>::doSave( const T& ref )
{
  std::cout << "Doesn't support save. Value is " << ref << std::endl;
}

template<>
template<typename T>
void saver<true>::doSave( const T& ref )
{
  ref.save();
}

//------------------------------------------------------------------------------


template<typename T>
void save( const T& ref )
{
  // hier wird entschieden ob save verfügbar ist oder nicht und dann die

  // entsprechende Methode der Hilfsklasse saver aufgerufen

  saver<supports_save<T>::value>::doSave(ref);
}

//------------------------------------------------------------------------------


int main()
{
  int i = 0;
  Test test;

  save(i);
  save(test);

  return 0;
}


Du kanst aber auch wie zb bei den Iteratoren einen Tag für 'save'-Unterstützung einführen und dann danach unterscheiden...
Tutorials zu OpenGL, Ubuntu und Programmieren allgemein: www.tomprogs.at

Forum und Wiki zum Programmieren lernen: proggen.org/forum.proggen.org

kiba

Alter Hase

  • »kiba« ist der Autor dieses Themas

Beiträge: 327

Wohnort: NRW

Beruf: Azubi: Fach-Info. Anw.

  • Private Nachricht senden

6

08.11.2009, 15:39

ahhh ok , noch eine frage gibts da ein möglichkeit ,das wenn man die Klasse FileData vererbt hat, das der Wert von supports_save<>::value automatisch
auf true gesetzt wird.

7

08.11.2009, 17:29

Zitat von »"kiba"«

ahhh ok , noch eine frage gibts da ein möglichkeit ,das wenn man die Klasse FileData vererbt hat, das der Wert von supports_save<>::value automatisch
auf true gesetzt wird.

Ja, es geht. Am einfachsten wäre es warscheinlich statt dem supports_save einfach is_base_of aus der Boost.TypeTraits Bibliothek zu nehmen:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <iostream>
#include <boost/type_traits/is_base_of.hpp>

//------------------------------------------------------------------------------


struct supports_save_tag {};

struct Test: private supports_save_tag
// Ob die Vererbung private ist, ist eigentlich egal, aber da es sich um

// ein Tag handelt wäre es falsch zu sagen Test ist ein supports_save_tag...

{
  void save() const
  { std::cout << "Save" << std::endl; }
};

struct AnotherTest: public Test
{
  void save() const
  { std::cout << "I can also save me..." << std::endl; }
};

//------------------------------------------------------------------------------


// ... gleich wie im vorigen post ...


//------------------------------------------------------------------------------


template<typename T>
void save( const T& ref )
{
  // hier wird entschieden ob save verfügbar ist oder nicht und dann die

  // entsprechende Methode der Hilfsklasse saver aufgerufen

  saver<boost::is_base_of<supports_save_tag,T>::value>::doSave(ref);
}

//------------------------------------------------------------------------------


int main()
{
  int i = 0;
  Test test;
  AnotherTest test2;

  save(i);
  save(test);
  save(test2);

  return 0;
}
Tutorials zu OpenGL, Ubuntu und Programmieren allgemein: www.tomprogs.at

Forum und Wiki zum Programmieren lernen: proggen.org/forum.proggen.org

Werbeanzeige