Is it recommed to put a while loop, which never ends in a constructor? Or should I use threads to get the same result? Is it good when a constructor never terminates? Or is it more secure to avoid segmentation faults?
Hope you understand my bad English..
An object does not exist if its constructor does not finish. So putting a while(1) loop in a constructor will prevent objects being created using that constructor. You need to describe what problem you think doing this will solve.
I'd say it's perfectly OK to spawn a thread from a constructor, and a horribly bad idea to have an endless loop in the constructor.
In code, the following is OK:
void start_a_thread_with_a_loop()
{
while(1)
{
// consider a while(!stop_condition) or something
// do something in a loop
}
}
class x
{
public:
x()
{
start_a_thread_with_a_loop();
}
};
And the following would be at least a bad idea:
class x
{
public:
x()
{
while(1)
{
}
}
};
Good thing though, is that likely you wouldn't be able to use such object, for reasons Neil pointed out :)
Is it recommed to put a while loop, which never ends in a constructor?
No.
Or should I use threads to get the same result?
No.
Is it good when a constructor never terminates?
No.
Or is it more secure to avoid segmentation faults?
No.
What problem are you trying to solve?
In embedded systems, most endless loops should be avoided. They should either be timed or counted iterations. If the loop is terminated, an error check should be performed. This refrains from the system being "locked up".
One exception to the rule is the background loop. This is the main loop in which events are checked and keeps the machine running. Without this loop, machines may just terminate or halt.
Your code shouldn't generate a segmentation fault whether or not it uses multiple threads or contains infinite loops.
None of those have anything to do with segmentation faults. If those occur, you need to fix that problem