detect private/public constructor at compile time?

[fschaper]

hello,

is it possible to determine if an constructor is public or private at compile time using template metaprogramming/SFINAE?

kind regards and thanks in advance for the help,

florian

[weaknessforcats]

Yep. If the constructor is priviate, your code won't compile if you try to create an object using that constructor.

A private constructor is commonly used to prevent users from creating objects with it. Like a private copy constructor prevents making copies of the object forcing the users to use pointers or references in calls.

[fschaper]

Yep. If the constructor is priviate, your code won't compile if you try to create an object using that constructor. ...

Thanks for the answer but that is not really what I meant.
I should be more specific!

This is what I have:

template<class T>
class Singleton : public boost::noncopyable {
    typedef Singleton<T> singleton_type;
    typedef T object_type;
public:
    static object_type& getInstance() {
        static object_type instance;
        return instance;
    }
 
protected:
    Singleton() {}
    ~Singleton() {}
};
 
class TestClass : public Singleton<TestClass> {
  friend class Singleton<TestClass>;
private:
  TestClass();
};
 

This design suffers from the fact that the user of the singleton baseclass will still have to define his Constructor as private. If it doesn't, the code will still compile clean but will break the singleton design principle.

What I wanted now is a mpl check that would test if it is at all possible to instantiate "TestClass" without using the "getInstance" method of the singleton class to emit a compile time error (possibly using BOOST_STATIC_ASSERT) and thereby enforce the Singleton pattern.

any ideas?

[weaknessforcats]

Would you please read the article on Singleton in the C/C++ Articles forum.

There's so much wrong with your singleton hierarchy that I don't quite know where to begin.

[fschaper]

Would you please read the article on Singleton in the C/C++ Articles forum.

There's so much wrong with your singleton hierarchy that I don't quite know where to begin.

Well my question was not really about the singleton pattern but about some way to determine if a class can be instantiated from one object or not (without forcing an compile time failure). Thats why I was hinting at some possible SFINAE solution [http://en.wikipedia.org/wiki/Substit...s_not_an_error ].

But since you mentioned some fundamental flaw in the code I posted as well
I'm of course interested what your criticism is really based on?

There are a couple of ways to go about this but I don't see how this would be a non-solution right now.

./regards

Florian

[weaknessforcats]

1) Why is Singleton a friend to TestClass. That allows Singleton access to TestClass data members but since Singleton doesn't know about TestClass data members becuse it's a base class. This is pointless. friend classes are a big no-no.

2) The instance method is supposed to return rthe address of the Singleton and not some value like object_type. I would expect a Singleton* rather than , say, an int. That's becuse I don't know if it's an int. All I know is it's a Singleton.

3) The Singleton needs to be on the heap.

4) The Singleton needs to be identified by a name since there can probable be several Singletons. That requires a Singleton Registry.

5) The Singleton needs to set designed for Visitor.

6) The Singleton address fetched by the Instance() function should be in an anonymous namespace (or declared static in the source file containing the Singleton code) to prevent access by means other than using the Instance() method.

7) I get an error tryitng to compile TestClass.

template <class T>
class TestClass : public Singleton<TestClass> {
friend class Singleton<TestClass>;
private:
TestClass();
};

Visual Studio.NET 2005 won't accept Singleton<TestClass> because TestClass is a template and needs a type:

\question2007-11-01-a.cpp(19) : error C3203: 'TestClass' : unspecialized class template can't be used as a template argument for template parameter 'T', expected a real type
        c:\scratch\instructor\question2007-11-01-a.cpp(23) : see reference to class template instantiation 'TestClass<T>' being compiled
 

The template needs to be:

template <class T>
class TestClass : public Singleton<TestClass<T> > {
  friend class Singleton<TestClass<T> >;
private:
  TestClass();
};
 

How is yours compiling?

8) This won't compile:

TestClass<int> t;
 

It needs to call Singleton::Singleton() which is private.

How are you able to create TestClass objects?

9) etc...

[fschaper]

Thanks for taking the time ...

1) Why is Singleton a friend to TestClass. That allows Singleton access to TestClass data members but since Singleton doesn't know about TestClass data members becuse it's a base class. This is pointless. friend classes are a big no-no.
[...]

I need the friend class declaration because the constructor of TestClass needs to be private (something I still hope to be able to enforce) to fullfill the constrains of the singleton pattern. The singeton class has to be able to create the initial object during the first pass in the getInstance method.

As to the Baseclass have a look at CRTP [http://en.wikipedia.org/wiki/Curious...mplate_pattern]

2) The instance method is supposed to return rthe address of the Singleton and not some value like object_type. I would expect a Singleton* rather than , say, an int. That's becuse I don't know if it's an int. All I know is it's a Singleton.

TestClass& test = TestClass::getInstance();

3) The Singleton needs to be on the heap.

I don't see your point here. If thread safety is not of concern for me I don't see a problem. If thread safety is of interest the design can be easily enhanced so that you would force instatiation of "T" before entering main.

4) The Singleton needs to be identified by a name since there can probable be several Singletons. That requires a Singleton Registry.

Well I don't agree here either. What you are getting at is the original sample implementation of the GoF Singleton. The way I see it, these are samples, and by no means cast in stone. There are some basic rules which make a singleton a singleton. A singleton has not by definition to follow the original implementation.

Having some sort of string based lookup in some singleton registry suffers from the fact that errors (I f.ex. might have misspelled the name I registered the singleton with) would not be detected at compile time but during runtime.

Independent singletons can be instatiated independently:

class TestClassA : public Singleton<TestClassA> {
...
};
 
class TestClassB : public Singleton<TestClassB> {
...
};
 
TestClassA& a = TestClassA::getInstance();
TestClassB& b = TestClassB::getInstance();
 

5) The Singleton needs to set designed for Visitor.

Sorry, I don't understand. Could you elaborate on this?

6) The Singleton address fetched by the Instance() function should be in an anonymous namespace (or declared static in the source file containing the Singleton code) to prevent access by means other than using the Instance() method.

The object that I try to encapsule within the singeton is pretty much only accessible by accessing the getInstance() method of the singeton.

7) I get an error tryitng to compile TestClass.


Visual Studio.NET 2005 won't accept Singleton<TestClass> because TestClass is a template and needs a type:

\question2007-11-01-a.cpp(19) : error C3203: 'TestClass' : unspecialized class template can't be used as a template argument for template parameter 'T', expected a real type
        c:\scratch\instructor\question2007-11-01-a.cpp(23) : see reference to class template instantiation 'TestClass<T>' being compiled
 

The template needs to be:

template <class T>
class TestClass : public Singleton<TestClass<T> > {
  friend class Singleton<TestClass<T> >;
private:
  TestClass();
};
 

How is yours compiling?

8) This won't compile:

TestClass<int> t;
 

It needs to call Singleton::Singleton() which is private.

It was never intended to be used that way. The excample above (and further down) should make that clearer.

How are you able to create TestClass objects?

[...]

template<class T>
class Singleton {
public:
    typedef Singleton<T> singleton_type;
    typedef T object_type;
 
    static object_type& getInstance() {
        static object_type instance;
        return instance;
    }
 
protected:
    Singleton() {}
    ~Singleton() {}
 
private:
    Singleton( const singleton_type& );
    singleton_type& operator =( const singleton_type& );
};
 
class TestClass : public Singleton<TestClass> {
    friend class Singleton<TestClass>;
public:
    int someMethod() { return 0; }
private:
    TestClass() {}
};
 
 
int main(int /*argc*/, char* /*argv[]*/)
{
    TestClass& p1 = TestClass::getInstance();
    p1.someMethod();
    return 0;
}
 

This should compile clean with your copy of vs2005,
it does with mine.