Q:

Structure or Class with variable number of members

I want to create a structure/class with a variable number of class members which could be decided at compilation stage (like done in template metaprogramming)
Example : Its hypothetical in which both type and variable names are to be specified like Type T1 variable name should be varName1 and so on .....
template <class T1 (varName1) >
MyClass
{
     T1 varName1;

}

template <class T1 (varName1), class T2 (varName2) >
MyClass
{
     T1 varName1;
     T1 varName2;
}

and in main code which can be declared like following or some other way in which type and name can be specified
MyClass Obj;
and MyClass::somefunc() can access variable names
as follows
MyClass::somefunc()
{
     std::cout <<" abc value : " << abc << std::endl;
     std::cout <<" xyz value : " << xyz << std::endl;
}

Is this possible via template metaprogramming in C++ to have both type and variable name specification ?

A:

With template metaprogramming and little preprocessing, it is possible to achieve a syntax close to desirable:
//one has to "declare" once an attribute name to be able to use
//it later in any number of class declarations
DECLARE_ATTRIBUTE_NAME(foo);
DECLARE_ATTRIBUTE_NAME(quux);
DECLARE_ATTRIBUTE_NAME(bar);
DECLARE_ATTRIBUTE_NAME(baz);

//pass types and declared attribute names, separated by comma
typedef TupleWithNamedMembers<int, foo,
                              float, quux,
                              double, bar,
                              char, baz
                        > MyTuple;
//extra call to macro "MAKE_TUPLE" can be avoided, see below
class MyConstruct: public MAKE_TUPLE(MyTuple)
{ };

//usage
int main(int argc, char* argv[])
{
    MyConstruct construct;
    construct.foo = 3;
    construct.bar = 5.6;
    construct.quux = 8.9;
    construct.baz = 'h';
    return 0;
}

The implementation:
#ifndef TupleWithNamedMembersH
#define TupleWithNamedMembersH
//---------------------------------------------------------------------------

#include <Loki/typelist.h>
#include <Loki/HierarchyGenerators.h>

template<class T, int a>
struct attribute
{
};

//the generated id is not really unique in all cases
//one should provide better implementation
#define GENERATE_UNIQ_ID(name) ((sizeof(#name)<<16)|__LINE__)

//specializations of the struct "attribute" act like compile-time map between
//a name ID and an attribute name 
#define DECLARE_ATTRIBUTE_NAME_IMPL(name, id) \
    enum { id = GENERATE_UNIQ_ID(name) }; \
    template<class T> \
    struct attribute<T,id> \
    {\
        T name;\
    };
#define DECLARE_ATTRIBUTE_NAME(name)\
    DECLARE_ATTRIBUTE_NAME_IMPL(name, name)

//helps to pass pair of type and name ID as a single type
template<class T, int i>
struct pair
{
    static const int val = i;
    typedef T type;
};

//unpacks compile-time data from PairT and inherits attribute
//with name selected by ID
template<class PairT>
class holder: public attribute<typename PairT::type,PairT::val>
{    };

//turns template arguments into Loki::TypeList
template
<
    typename T1  = Loki::NullType, int i1 = 0, typename T2  = Loki::NullType, int i2 = 0,
    typename T3  = Loki::NullType, int i3 = 0, typename T4  = Loki::NullType, int i4 = 0,
    typename T5  = Loki::NullType, int i5 = 0, typename T6  = Loki::NullType, int i6 = 0,
    typename T7  = Loki::NullType, int i7 = 0, typename T8  = Loki::NullType, int i8 = 0,
    typename T9  = Loki::NullType, int i9 = 0, typename T10 = Loki::NullType, int i10 = 0
>
struct TupleWithNamedMembers
{
public:
    typedef Loki::TL::MakeTypelist<pair<T1,i1>, pair<T2,i2>,
                                   pair<T3,i3>, pair<T4,i4>,
                                   pair<T5,i5>, pair<T6,i6>,
                                   pair<T7,i7>, pair<T8,i8>,
                                   pair<T9,i9>, pair<T10,i10>
                         >::Result Result;
};

//this macro is required because of internal compiler error that I encounter
//Loki::GenScatterHierarchy makes a class inherit every attribute from the type list
#define MAKE_TUPLE(types) Loki::GenScatterHierarchy<types::Result, holder>

#endif //end of "TupleWithNamedMembers.h"

Notes:
The MAKE_TUPLE macro should be a metafunction, if your compiler is OK with the code below:
template
<
    typename T1  = Loki::NullType, int i1 = 0, typename T2  = Loki::NullType, int i2 = 0,
    typename T3  = Loki::NullType, int i3 = 0, typename T4  = Loki::NullType, int i4 = 0,
    typename T5  = Loki::NullType, int i5 = 0, typename T6  = Loki::NullType, int i6 = 0,
    typename T7  = Loki::NullType, int i7 = 0, typename T8  = Loki::NullType, int i8 = 0,
    typename T9  = Loki::NullType, int i9 = 0, typename T10 = Loki::NullType, int i10 = 0
>
struct MakeTupleWithNamedMembers
{
private:
    typedef Loki::TL::MakeTypelist<pair<T1,i1>, pair<T2,i2>,
                                   pair<T3,i3>, pair<T4,i4>,
                                   pair<T5,i5>, pair<T6,i6>,
                                   pair<T7,i7>, pair<T8,i8>,
                                   pair<T9,i9>, pair<T10,i10>
                         >::Result type_list;
public:
    typedef Loki::GenScatterHierarchy<type_list, holder> Result;
};

//usage
class MyConstruct: public MakeTupleWithNamedMembers<int, foo, float, quux>::Result
{ };

A:

Not possible as described.  You might get equivalent functionality using boost's preprocessor library.
Ultimately what you're asking for differs from simply passing say...
struct Members
{
    int a_;
    double b_;
};

...into...
template <class Members>
class Add_Stuff : public Members
{
  public:
    doSomething() { ... };
};

...in that doSomething is given the ability to iterate over and print the members, right?
You can also write a simple program/script that reads a list of types and identifiers and outputs the C++ code you require.  If you have a lot of fields to deal with, this is probably a good approach.  As a minimal off-the-top-of-my-head outline, and assuming input like so the newlines enforce a simple type vs identifier division (making you create typedefs for arrays etc):
std::string
idn1
const int*
idn2
my_typedef
ind3

...you can generate some C++ code ala...
std::ostringstream streaming;
streaming << "    void somefunc() const\n{\n    std::cout ";

cout << "class " << class_name << "\n{\n";
while (cin.getline(type) && cin.getline(identifier))
{
    cout << "    " << type << ' ' << identifier << '\n';
    streaming << "<< \"" << identifier << " \" << identifier << "\n        ";
}
cout << "  public:\n" << streaming.str() << "\n"
        "};\n";

Obviously you could clean up the input to allow a more natural C++ expression of types and identifiers and complicate the parsing logic - a regexp may be good enough for your needs, or you could try spirit or do it yourself.
Preprocessor hackery can achieve something similar directly inside C++, but IMHO it will be even uglier and more time consuming to write and maintain.
If you don't actually need to access the members by identifier, you might do what TokenMacGuy suggests if every field can have the same type (not so bad - consider boost::variant or ~::any), or there's another option if you can ensure every field has a distinct type (again, this can be forced via trivial wrapper template classes): what I call a "type map" - where you can use the type as a key into what's effectively an associative container of type-distinct values, with all lookup resolved at compile time and support for the automatic iteration needed for your somefunc() implementation.  Could combine that with strings for run-time type naming if desired, but can't achieve identifier strings that are resolved or validated at compile time.
I implemented such maybe 6 years ago (atop Alexandrescu's Loki library using type lists) and asked on the boost mailing list whether anyone was interested, but nobody saw the utility of it and I didn't really try to explain.  It's actually very useful for logging systems, which prompted me to write it in the first place.  Anyway, I suspect I didn't bother to post code to the vault for that one, and don't have it handy, so you'd need to start from scratch unless MPL or some other library has implemented their own similar "container" meanwhile (or beforehand...?).

