Multithreading Design, protect global member in C++ - c++

Question

I am writing a c++ app with QT, with a focus at speed optimization.
I want to have a few global objects with read only access for different threads.
Before I open the threads, I have to initialize the global objects and fill them with data.
How I can protect the set functions of my Global Objects, but still have access from the main function?
Example code like it is now:
myClass.h
class MyObjectClass {
public:
void SetSome(const QList<QString> &value);
QList<QString> GetSome() const;
private:
QList<QString> m_myMember;
};
main.cpp
#include "global.h" // some like: extern MyObjectClass g_InihalizedInMain;
#include "anyThread.h"
int main(){
g_InitializedInMain.SetSome() // This Shut work
MyThread thread;
thread.start();
//..
return 0;
}
anyThread.cpp:
#include "global.h"
void thread::run()
{
MyObjectClass newObject = g_InihalizedInMain; //This shut work
g_InitializedInMain.GetSome(); //This shut work
g_InitializedInMain.SetSome(); //This shut not work and give me an error during compile time
newObject.SetSome(); //This shut work
}
I would be happy if you have a few design ideas for me, thanks a lot!

Answer 1

class MyPrivateObjectClass : private MyObjectClass
{
public:
friend void main();
};
extern MyPrivateObjectClass g_InitializedInMain;

Answer 2

Make your global variable static which means only the one source file can access it. You can then provide accessor functions that can read the data from other threads.

Answer 3

For starters, I would try to avoid global variables at all costs.
What you could do instead of global variables is to instantiate a variable in main (either
dynamically, or locally on the stack, depending on your preferences)
and set it in the thread object (this is called dependency injection)
To control setting attributes on MyObjectClass only from main, I can think of 2 options:
Set all of the MyObjectClass attributes via the constructor in main, thus allowing you to remove the setters, but leave the getters. The MyObjectClass would be immutable.
Create a context object that contains all the settable attributes for MyObjectClass. This context object can only be passed into the MyObjectClass constructor. The context object should be created in main, calling the appropriate setters, then passed into MyObjectClass upon instantiation from main. The MyObjectClass class uses these attributes from the context object internally, but doesnt have setters for them. There would of course be getters available on MyObjectClass, that would get the values from the internal context object. The MyObjectClass would be immutable, but this way is a bit more flexible.
I prefer the second option. Here is a code sample:
myClass.h
class MyObjectContext {
public:
void SetSome(const QList<QString> &value);
QList<QString> GetSome() const;
private:
QList<QString> m_myMember;
};
class MyObjectClass {
public:
MyObjectClass(MyObjectContext *context) : context_(context) {}
QList<QString> GetSome() const {return context_->GetSome();}
// Put the rest of the important stuff here
private:
MyObjectContext *context_;
MyObjectClass(); // explicitly stating that the default ctor cant be called
};
main.cpp
int main(){
// creating these objects on the stack, you may need
// to create them dynamically, its up to you
MyObjectContext context;
context.SetSome() // This Should work
MyObjectClass moc(&context);
MyThread thread(&moc);
thread.start();
//..
return 0;
}
anyThread.h
class MyThread : public QThread { // Assuming you're inheriting from QThread
public:
// instead of setting it via the ctor, you could consider adding a setter
MyThread(MyObjectClass *moc) : moc_(moc) {}
void run();
private:
MyThread(); // explicitly stating that the default ctor cant be called
MyObjecctClass *moc_
};
anyThread.cpp
void MyThread::run()
{
moc_->GetSome(); //This should work
// Dont have to worry about the setters, since there are none
// available for the MyObjectClass, which is now immutable
}