Variable Argumentlisten und Abgeleitete Klassen

Morph01

Hi ...mal wieder,
ich hab ein Problem, und zwar würde ich gern variable Argumentlisten mit abgeleiteten Klassen als Argumente benutzen. Geht aber nicht. Mit diesem Code:

#include <stdarg.h>

class A_std {};
class A_abg : public A_std {};

template <class Type>
Type machwas ( int len_in, Type obj, ...)
{
    va_list vlpt;
    Type z=obj;
    int len = len_in;
    Type *chain;

    va_start(vlpt,obj);

    for ( int i=0; i<len; i++)
    {
        chain[i] = z;
        z = va_arg(vlpt,Type);
    }

    va_end(vlpt);
}

int main()
{
    A_abg klaus;
    machwas<A_abg> ( 1,klaus); 
}

bekomme ich diese Warnungen:

vararg.c++: In function `Type machwas(int, Type, ...) [with Type = A_abg]':
vararg.c++:29:   instantiated from here
vararg.c++:20: warning: cannot receive objects of non-POD type `class A_abg' trough `...'; call will abort at runtime

Und sobald ich das Programm starte ein "Segmentation Fault".
Wenn ich statt A_abg A_std nehme, funktionierts.

Wieso kann der keine Abgeleiteten Klassen benutzen? Und vor allem, kann ich ihn dazu bringen, doch Abgeleitete Klassen zu benutzen?

Danke fürs Lesen,

Morph

In C++ benutzt man sowas nicht.

Morph01

Fand die Antwort jetzt so mäßig konstruktiv...

Naja, wie auch immer, habs jetzt (natürlich 2 minuten nachdem ich die Frage nach langem Nachdenken gepostet hab) selbst gelöst. Ich übergebe jetzt statt eines Objekts einen Zeiger auf das Objekt. Funktioniert ...denke ich.

Morph

hör lieber auf rule of thumb. wurde hier auch schon öfters besprochen das man variable argumenten listen nicht in c++ benutzen soll. vielleicht nützt die suchfunktion.

Morph01

Ich möchte ja nun nicht faul erscheinen, aber unter "Argumentlisten" oder ähnlichen Stichwörtern finde ich garnichts. Wie macht man das denn in C++ ?

Danke,

Morph

evilissimo

So z.b.

#include <vector>
#include <iostream>

class A_std {};
class A_abg : public A_std {};

template <class Type>
Type machwas ( std::vector<Type> const & arglist)
{
  std::cout << arglist.size() <<std::endl;
  return Type();
}

int main()
{
    A_abg klaus;
    std::vector<A_abg> vec(5,klaus);
    machwas(vec);
}

Morph01

Damit hätte ich doch 5 Kopien des Objekts klaus, oder?
Ich möchte aber unterschiedliche Objekte übergeben:

//Klassen und machwas() wie gehabt
int main()
{
A_abg horst;
A_abg kurt;
machwas(2,horst,kurt);
}

Walli

Dann füllst du den Vector halt anders...

finix

// Loesungs"ansatz"
template <typename T>
struct ArgumentList
{
  ArgumentList& add( const T& arg );

  vector<T>  args;
};

template <typename T>
ArgumentList<T>& ArgumentList<T>::add( const T& arg )
{
  args.push_back(arg);
  return *this;
}

// Verwendung
some_function(ArgumentList<Type>().add(horst).add(kurt));

Morph01

Hey, das is ne idee!
Danke sehr!

Morph