extern must have access to class constructor? - c++

Question

There are many ways to access class members as you all know, my problem now is. if the class constructor/deconstructor if public, the 'new' usage is allowed and also 'extern', if it is private, i can make 'GetInstance' only class which wouldn't allow 'new' usage, which is good for class that should have 1 pointing instance to them only (such as a server which counts current logged in users), and 'new' is good for classe that point to many objects (such as a class that points to a new objects, for example a new player logged int, it would create a new pointer to each on of them ), and a map would store a pointer to a 'new' of that object. The problem is, shouldnt 'extern' be allowed to access from a global object private constructors? since 'new' usage isnt allowed? Take a look at the example below:
#include <windows.h>
#include <cstdlib>
#include <iostream>
#include <map>
using namespace std;
//CMover.h-------------------------------------
#define MAX_MOVER_NAME 32
class CMover
{
private:
BOOL m_bInitialized;
BOOL m_bIsWalking;
unsigned m_uMetersPercused;
TCHAR m_szName[MAX_MOVER_NAME+1];
//CMover( LPCTSTR szMoverName, BOOL bInitialized = TRUE, BOOL bWalking = TRUE, unsigned uMeters = 0 );
public:
CMover() { };
virtual ~CMover(){};
};
//---------------------------------------------
//CMover.cpp---------------
CMover g_Mover; //CMover was created in order to have many 'new' usage, so each 'new' object points to a new player
// Making a global object of it is a big failure
//---------------------------
//CServer.h---------------
class CConnectedUsers
{
private:
CConnectedUsers() {}; //ok, new cannot access, this class should be used as 1 object only
virtual ~CConnectedUsers() {}; //to count up connected users, 'new' should never be used
public:
map<u_long,CMover*>m_UserMng;
//I Could use GetInstance, that any pointers craeted (CConnectedUsers *pCUser = CConnectedUsers::GetInstance() ) would
//point to it
static CConnectedUsers* GetInstance( void )
{
static CConnectedUsers mObj;
return &mObj;
}
};
//------------------------
//CServer.cpp ------
//Or in this case i would like to make a global object, so on CWhatever.cpp that included CServer.h i could use
//(extern CConnectedUsers g_Users;) which is also 1 object-only so no GetInstance would be needed and I would use
//(g_Users.m_UserMng...) directly after external declared
//PROBLEM is, making constructor private regulates the class to be 1 object only, but it doesn't allow external usage
//why is that???
CConnectedUsers g_Users;
//-----------------
//Main.cpp ...etcc
int main( int argc, char *argv[] )
{
CMover *pMover = new CMover;
cout << pMover << endl << &pMover << endl; //points to a new object, pointer stored in a region
CMover *pMov2 = new CMover;
cout << pMov2 << endl << &pMov2 << endl << endl; //points to a new object, pointer stored in another region
CConnectedUsers *pCUser = CConnectedUsers::GetInstance();
CConnectedUsers *pCUser2 = CConnectedUsers::GetInstance();
cout << pCUser << endl << &pCUser << endl; //points to CConnectedUsers, pointer stored in a region
cout << pCUser2 << endl << &pCUser2 << endl; //points to same CConnectedUsers, pointer stored in another region
//also another question is, do I need to check these pointers integrity by doing:
if( pCUser )
{
//??
}
system("pause>nul");
return EXIT_SUCCESS;
}

Answer 1

The problem isn't extern. A declaration with extern doesn't create an object, and doesn't need access to a constructor.
However, an extern reference has to find an object defined somewhere, and the one definition (not merely declaration) doesn't have access to the constructor, since it's a namespace member, not a class member.
This is completely expected and consistent. Expressions evaluated at namespace scope are outside the class and therefore have no special privilege wrt private members.
You can instead use a "lock-and-key" system to make a public constructor unusable from any other file. For example:
// header file
class Once
{
public:
struct Forward;
Once(Forward);
};
extern Once g_singleton;
// implementation file
#include "Once"
namespace { struct Local {}; }
struct Once::Forward : Local {};
Once g_singleton(Once::Forward());
It is impossible to instantiate the class from any other compilation unit, since no other compilation unit has the definition of Once::Forward, which must be passed by value to the constructor. And any attempt to define Once::Forward in any other compilation unit will be an ODR violation.