Question: 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..

Answer: 
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 :)
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.