By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
454,503 Members | 1,628 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 454,503 IT Pros & Developers. It's quick & easy.

template type only known at runtime

P: n/a
Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:

-----

#include <string>

template <class Tclass foo {
T x;
public:
void do_something_depending_on_type_of_T(){

...
};
}

int main(int argc, char *argv[]) {
if (argc==1) //default type string should be used
foo<std::stringbar;
else //use class int
foo<intbar;
bar.do_something_depending_on_type_of_T();
return 0;
}

-----

I know it doesn't work like this but is it possible at all?

Ralf

Nov 18 '08 #1
Share this Question
Share on Google+
8 Replies


P: n/a
On 18 nov, 08:51, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:

-----

#include <string>

template <class Tclass foo {
* * T x;
public:
* * void do_something_depending_on_type_of_T(){

* * * * ...
* * };

}

int main(int argc, char *argv[]) {
* * if (argc==1) //default type string should be used
* * * * foo<std::stringbar;
* * else //use class int
* * * * foo<intbar;
* * bar.do_something_depending_on_type_of_T();
* * return 0;

}
Template based code is constructed at compile time (static
polymorphism). If you need dynamic polymorphism use virtual functions.
However, your code has a general C++ problem (not specific to
templates). The line bar.do_something_depending_on_type_of_T(); will
generate an error because bar is undefined. This would happen even if
bar was not a template.

I don't know if this is the best design for you. But the closest I can
get to it is through template specialization:

emplate <class Tclass foo
{
public:
void do_something()
{} //You don't need trailing semi-colon here.
}; //You need it here though.

template <class foo<std::string>
{
public:
void do_something()
{ /*Implementation for string */ }
};

template <class foo<int>
{
public:
void do_something()
{ /*Implementation for int */ }
};

int main(int argc, char *argv[])
{
foo<std::stringstringBar;
foo<intintBar;
if (argc==1)
stringBar.do_something();
else
intBar.do_something();
return 0;
}

--
Leandro T. C. Melo
Nov 18 '08 #2

P: n/a
On Nov 18, 1:51*pm, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
I know it doesn't work like this but is it possible at all?
It wouldn't work even if you solve your problems with templates
because of scoping:
int main(int argc, char *argv[]) {
if (argc==1) //default type string should be used
foo<std::stringbar;
else //use class int
foo<intbar;
bar.do_something_depending_on_type_of_T();
bar is undefined here (out of scope).
return 0;
}
Nov 18 '08 #3

P: n/a
On Nov 18, 1:51*pm, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:
The most painless solution I think looks like:

int main(int argc, char *argv[]) {
* * if (argc == 1) {
* * * * foo<std::stringbar;
bar.do_something_depending_on_type_of_T();
} else {
* * * * foo<intbar;
bar.do_something_depending_on_type_of_T();
}
* * return 0;
}

Of course, may be a better solution also exists.
Nov 18 '08 #4

P: n/a
maverik wrote:
On Nov 18, 1:51*pm, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
>I know it doesn't work like this but is it possible at all?

It wouldn't work even if you solve your problems with templates
because of scoping:
I know about the scoping problem. The code was just there to illustrate
what I want which was hard for me to describe in prose. The problem is
similar to one I had a year ago or so. I had wanted to create a
reference to cin or an ifstream object depending on how the program was
invoked. At that time I was wondering why C++ didn't have a deferred
intialization feature for references like

istream &config;
ifstream ifs;
if (config_is_read_from_cin) config=cin; else config=ifs;

It can be done with pointers why not with references. Anyway, it seems I
have to use the apprach you gave in the other posting, thanks, also to
Leandro.

Ralf
Nov 18 '08 #5

P: n/a
Ralf Goertz wrote:
maverik wrote:
>On Nov 18, 1:51 pm, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
>>I know it doesn't work like this but is it possible at all?
It wouldn't work even if you solve your problems with templates
because of scoping:

I know about the scoping problem. The code was just there to illustrate
what I want which was hard for me to describe in prose. The problem is
similar to one I had a year ago or so. I had wanted to create a
reference to cin or an ifstream object depending on how the program was
invoked. At that time I was wondering why C++ didn't have a deferred
intialization feature for references like

istream &config;
ifstream ifs;
if (config_is_read_from_cin) config=cin; else config=ifs;

It can be done with pointers why not with references. [...]
std::istream& is = config_is_read_from_cin ? std::cin : ifs;
Ralf
Schobi
Nov 18 '08 #6

P: n/a
maverik wrote:
On Nov 18, 1:51 pm, Ralf Goertz
<r_goe...@expires-2006-11-30.arcornews.dewrote:
>Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:

The most painless solution I think looks like:

int main(int argc, char *argv[]) {
if (argc == 1) {
foo<std::stringbar;
bar.do_something_depending_on_type_of_T();
} else {
foo<intbar;
bar.do_something_depending_on_type_of_T();
}
return 0;
}

Of course, may be a better solution also exists.
template< class T >
inline void do_it() {foo<int>().do_something_depending_on_type_of_T(); )

int main(int argc, char *argv[]) {
if (argc == 1) {
do_it<std::string>();
} else {
do_it<int>();
}
return 0;
}

Schobi
Nov 18 '08 #7

P: n/a
Ralf Goertz wrote:
Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:
If the type is only known at run-time, you need run-time
polymorphy, which is done using virtual functions and
inheritance. However, that doesn't mean you can't use
templates at all:

class foo_base {
public:
virtual void do_something_depending_on_type_of_T() = 0;
};

template< typename T >
class foo : public foo_base {
public:
virtual void do_something_depending_on_type_of_T() {}
};
[...]
Ralf
Schobi
Nov 18 '08 #8

P: n/a
Hendrik Schober wrote:
Ralf Goertz wrote:
>Hi,

I want to do able to declare an object bar of a templated class foo
where the actual template type of foo is only know at runtime:

If the type is only known at run-time, you need run-time
polymorphy, which is done using virtual functions and
inheritance. However, that doesn't mean you can't use
templates at all:

class foo_base {
public: virtual void do_something_depending_on_type_of_T() = 0; };
virtual void do_something_depending_on_type_of_T() = 0;
};

template< typename T >
class foo : public foo_base {
public:
virtual void do_something_depending_on_type_of_T() {}
};

Actually, I just need two different types for the template,
foo<std::stringand foo<int>. The only difference is the id type I get
from a database, it can be either integer or char and is known only at
runtime. If it is numeric I still have to do some calculations with it
(so I can't just sql-cast it to char and use std::string in my program).
Also, the way of writing back the data to the db differs because of
quoting. "id" must be part of the class as I also need it for
std::map<T,doublewithin class foo. But wrapping it in another template
function as you also suggested seems to be the way to go.

Thanks for the ternary ?: suggestion in the other posting!

Ralf
Nov 19 '08 #9

This discussion thread is closed

Replies have been disabled for this discussion.