|
|
 |
 |
 |
 |
retrieving templatized object via singleton getInstance using generic template parameters
I want to call a singleton getInstance function to retrieve a
templatized object without knowing what types were used to create the
singleton object in the first call to getInstance. How can I do this
non-intrusively -- I.e., without, for example, typedef'ing the types
in every compilation unit?
Background:
Our code base has assert macros that need to reboot the system after
notifying components via a single templatized Component object that
contains the IPC object. I made the macro call a reboot function, but
that function needs to access the IPC object. I want to singleton'ize
the Component object to provide access to the IPC object, but don't
want to hand-code the template parameters in each compilation unit for
each getInstance call.
Code:
// I want to call retrieve a templatized object via a call to
getInstance
// without supplying the objects template parameters.
// Is there any way to do this, perhaps using template meta-
programming (TMP) techniques?
#include <string>
#include <iostream>
using namespace std;
template <typename T1, typename T2>
class Component
{
public:
static Component<T1, T2> getInstance()
{
static Component<T1, T2> t;
return t;
}
};
int main()
{
// after the initial call to getInstance, here
Component<int, string> & r1 = Component<int,
string>::getInstance();
// I then want to call getInstance to obtain the same Component
without specifying the template params.
Component<something generic> & r2 = Component<something
generic>::getInstance();
}
On Jun 5, 8:05 pm, gary.bernst@gmail.com wrote:
> I want to call a singleton getInstance function to retrieve a > templatized object without knowing what types were used to create the > singleton object in the first call to getInstance. How can I do this > non-intrusively -- I.e., without, for example, typedef'ing the types > in every compilation unit? > Background:
> Our code base has assert macros that need to reboot the system after
> notifying components via a single templatized Component object that
> contains the IPC object. I made the macro call a reboot function, but
> that function needs to access the IPC object. I want to singleton'ize
> the Component object to provide access to the IPC object, but don't
> want to hand-code the template parameters in each compilation unit for
> each getInstance call.
> Code:
> // I want to call retrieve a templatized object via a call to
> getInstance
> // without supplying the objects template parameters.
> // Is there any way to do this, perhaps using template meta-
> programming (TMP) techniques?
> #include <string>
> #include <iostream>
> using namespace std;
> template <typename T1, typename T2>
> class Component
> {
> public:
> static Component<T1, T2> getInstance()
> {
> static Component<T1, T2> t;
> return t;
> }
> };
> int main()
> {
> // after the initial call to getInstance, here
> Component<int, string> & r1 = Component<int,
> string>::getInstance();
> // I then want to call getInstance to obtain the same Component
> without specifying the template params.
> Component<something generic> & r2 = Component<something
> generic>::getInstance();
> }
toggle on the left.
Will this suffice?
On Jun 5, 8:05 pm, gary.bernst@gmail.com wrote:
> I want to call a singleton getInstance function to retrieve a > templatized object without knowing what types were used to create the > singleton object in the first call to getInstance. How can I do this > non-intrusively -- I.e., without, for example, typedef'ing the types > in every compilation unit? > Background:
> Our code base has assert macros that need to reboot the system after
> notifying components via a single templatized Component object that
> contains the IPC object. I made the macro call a reboot function, but
> that function needs to access the IPC object. I want to singleton'ize
> the Component object to provide access to the IPC object, but don't
> want to hand-code the template parameters in each compilation unit for
> each getInstance call.
> Code:
> // I want to call retrieve a templatized object via a call to
> getInstance
> // without supplying the objects template parameters.
> // Is there any way to do this, perhaps using template meta-
> programming (TMP) techniques?
> #include <string>
> #include <iostream>
> using namespace std;
> template <typename T1, typename T2>
> class Component
> {
> public:
> static Component<T1, T2> getInstance()
> {
> static Component<T1, T2> t;
> return t;
> }
> };
> int main()
> {
> // after the initial call to getInstance, here
> Component<int, string> & r1 = Component<int,
> string>::getInstance();
> // I then want to call getInstance to obtain the same Component
> without specifying the template params.
> Component<something generic> & r2 = Component<something
> generic>::getInstance();
> }
object I'm trying to use, which isn't templatized, but I'm still very
curious as to how a templatized object can be retrieved via
getInstance without providing the objects template parameters.
gary.bernst @gmail.com wrote: > I want to call a singleton getInstance function to retrieve a > templatized object without knowing what types were used to create the > singleton object in the first call to getInstance. How can I do this > non-intrusively -- I.e., without, for example, typedef'ing the types > in every compilation unit?
is to declare/define an object without specifying the actual type of
the object. That's impossible in C++.
Perhaps you can review your source and amend it with some kind of
example of how you're going to actually *use* the "object" you want
to retrieve?
> Background: > Our code base has assert macros that need to reboot the system after
> notifying components via a single templatized Component object that
> contains the IPC object. I made the macro call a reboot function, but
> that function needs to access the IPC object. I want to singleton'ize
> the Component object to provide access to the IPC object, but don't
> want to hand-code the template parameters in each compilation unit for
> each getInstance call.
some such option of the compiler...
> Code:
> // I want to call retrieve a templatized object via a call to
> getInstance
> // without supplying the objects template parameters.
> // Is there any way to do this, perhaps using template meta-
> programming (TMP) techniques?
> #include <string>
> #include <iostream>
> using namespace std;
> template <typename T1, typename T2>
> class Component
> {
> public:
> static Component<T1, T2> getInstance()
> {
> static Component<T1, T2> t;
> return t;
> }
> };
> int main()
> {
> // after the initial call to getInstance, here
> Component<int, string> & r1 = Component<int,
> string>::getInstance();
> // I then want to call getInstance to obtain the same Component
> without specifying the template params.
> Component<something generic> & r2 = Component<something
> generic>::getInstance();
> }
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
|
 |
 |
 |
 |
|
Add to del.icio.us |
Digg this |
Stumble it |
Powered by Megasolutions Inc