Storing a message from a queue

Question

I am doing a code review and I have encountered a class in an application that is throwing an exception in the constructor:

class QueueMessage
{
private:
    std::string m_bucketName;
    std::string m_objectName;

public:
    QueueMessage(const std::string& messageIn)
    {
        std::stringstream ss;
        ss << messageIn;
        PTree pt;
        json::read_json(ss, pt);
        m_bucketName = pt.get<std::string>("bucket");
        m_objectName = pt.get<std::string>("path");
        if (m_bucketName.empty() || m_objectName.empty())
        {
            throw QueueMessageException("Empty fields in queue message");
        }
    }

    std::string getBucketName() const { return m_bucketName; }
    std::string getObjectName() const { return m_objectName; }
};

The class is used to store the message from the queue (that is a JSON-like text) in its members. Is it ok to throw an exception in the constructor if the members of the class are string, int, vector, smart pointers, etc.?

Answer 1

Throwing exceptions from a constructor is not only a perfectly legitimate pattern to use. It is also necessary to correctly implement Resource Acquisition Is Initialization (RAII) for some classes (this appears to be the case in your code). And trust me, you really do want RAII :)

However, please be aware of the caveat that the destructor of the object will not be executed if the constructor throws. But the individual members of the class will be destructed.

On a related note, it is also okay for the constructor to perform work if the work is necessary for RAII. Again under the caveat that you adhere to Single Responsibility Principle (SRP) and Dependency Injection (DI). See this question: https://stackoverflow.com/questions/7048515/is-doing-a-lot-in-constructors-bad

Answer 2

Based on the comments the answer seems to be that throwing exception in constructor is not a bad practice if the members are not pointers. The problem of dynamically allocated memory management can be solved by using smart pointers, (like std::unique_ptr).