«

Hello,

I have a class which is used to encapsulate a RenderMan Interface
variable.
Generally speaking, such variable may be of integral, float, string type,
or an array of those.

I thought I could implement it by using a void pointer and a dynamically
created std::vector. The vector could be accessed by typed accessor
methods which would cast it to appropriate type, or throw an exception in
case of type mismatch.

e.g.

typedef std::vector<int> IntVector;
typedef std::vector<float> FloatVector;
typedef std::vector<std::string> StringVector;

class my {
public:
my() : ptr(NULL) {}
~my() { dump(); }

my& set(const IntVector& v)
{ dump(); ptr = new IntVector(v); }

my& set(const FloatVector& v)
{ dump(); ptr = new FloatVector(v); }

my& set(const StringVector& v)
{ dump(); ptr = new StringVector(v); }


IntVector get_intv()
{ return *static_cast<IntVector*>(ptr); }

FloatVector get_floatv()
{ return *static_cast<FloatVector*>(ptr); }

StringVector get_stringv()
{ return *static_cast<StringVector*>(ptr); }

private:
void dump() { if(ptr) delete ptr; }

void *ptr;
};

My question is ... am I doing something awkward, that could get me into
some trouble at a later time? Maybe I should simply go back and write the
class from ground up and not bother using std::vector at all?

Thanks in advance for your suggestions.

regards,
bartek

"bartek d" <> wrote in message
news:Xns93C9F13713364bartekdo2pl@153.19.0.141...
> Hello,
>
> I have a class which is used to encapsulate a RenderMan Interface
> variable.
> Generally speaking, such variable may be of integral, float, string type,
> or an array of those.
>
> I thought I could implement it by using a void pointer and a dynamically
> created std::vector. The vector could be accessed by typed accessor
> methods which would cast it to appropriate type, or throw an exception in
> case of type mismatch.
>
> e.g.
>
> typedef std::vector<int> IntVector;
> typedef std::vector<float> FloatVector;
> typedef std::vector<std::string> StringVector;
>
> class my {
> public:
> my() : ptr(NULL) {}
> ~my() { dump(); }
>
> my& set(const IntVector& v)
> { dump(); ptr = new IntVector(v); }
>
> my& set(const FloatVector& v)
> { dump(); ptr = new FloatVector(v); }
>
> my& set(const StringVector& v)
> { dump(); ptr = new StringVector(v); }
>
>
> IntVector get_intv()
> { return *static_cast<IntVector*>(ptr); }
>
> FloatVector get_floatv()
> { return *static_cast<FloatVector*>(ptr); }
>
> StringVector get_stringv()
> { return *static_cast<StringVector*>(ptr); }
>
> private:
> void dump() { if(ptr) delete ptr; }
>
> void *ptr;
> };
>
> My question is ... am I doing something awkward, that could get me into
> some trouble at a later time? Maybe I should simply go back and write the
> class from ground up and not bother using std::vector at all?
>
> Thanks in advance for your suggestions.
>
> regards,
> bartek

How about using a templated class?

"bartek d" <> wrote in message
news:Xns93C9F13713364bartekdo2pl@153.19.0.141...
> Hello,
>
> I have a class which is used to encapsulate a RenderMan Interface
> variable.
> Generally speaking, such variable may be of integral, float, string type,
> or an array of those.
>
> I thought I could implement it by using a void pointer and a dynamically
> created std::vector. The vector could be accessed by typed accessor
> methods which would cast it to appropriate type, or throw an exception in
> case of type mismatch.
>
> e.g.
>
> typedef std::vector<int> IntVector;
> typedef std::vector<float> FloatVector;
> typedef std::vector<std::string> StringVector;
>
> class my {
> public:
> my() : ptr(NULL) {}
> ~my() { dump(); }
>
> my& set(const IntVector& v)
> { dump(); ptr = new IntVector(v); }
>
> my& set(const FloatVector& v)
> { dump(); ptr = new FloatVector(v); }
>
> my& set(const StringVector& v)
> { dump(); ptr = new StringVector(v); }
>
>
> IntVector get_intv()
> { return *static_cast<IntVector*>(ptr); }
>
> FloatVector get_floatv()
> { return *static_cast<FloatVector*>(ptr); }
>
> StringVector get_stringv()
> { return *static_cast<StringVector*>(ptr); }
>
> private:
> void dump() { if(ptr) delete ptr; }
>
> void *ptr;
> };
>
> My question is ... am I doing something awkward, that could get me into
> some trouble at a later time? Maybe I should simply go back and write the
> class from ground up and not bother using std::vector at all?
>
> Thanks in advance for your suggestions.
>
> regards,
> bartek

Its not completely clear to me how your description fits with the class you
wrote. But

1) delete ptr will not compile since ptr is declared as void*.
2) You have no means of deciding which type you are actually holding.
3) You have no sensible copying or assigning behaviour which means this
class is difficult (at best) to use in a vector (if that is your intention).
4) The copying of vectors as return values in the get_* methods is very
inefficient.

Various trivial errors as well.

john

"John Harrison" <> wrote in
news:bgc5ja$n8au8$:

(...)

> Its not completely clear to me how your description fits with the
> class you wrote. But
>
> 1) delete ptr will not compile since ptr is declared as void*.
> 2) You have no means of deciding which type you are actually holding.
> 3) You have no sensible copying or assigning behaviour which means
> this class is difficult (at best) to use in a vector (if that is your
> intention). 4) The copying of vectors as return values in the get_*
> methods is very inefficient.

Ok my bad - I didn't mark it as a "sketch".
My point wasn't about the details, but rather about the general idea of
using a dynamically created std::vector. Is it a way?

I thought people in this newsgroup are more tolerant than a C++ compiler.


regards,
bartek

"jwtroll05" <> wrote in
news:bgc3m7$vf7$05$:

(...)

> How about using a templated class?

A templated class would be bound to a single type.
While I'd like it to contain one of several types, which can change at
runtime.

regards,
bartek