Question

There is a snippet from my code:

const std::pair<Info, const ElementHandler&>& handle () const {
                    FileHandler fileHandler = FileHandler();
                    std::pair<Info, const ElementHandler&> result = std::pair<Info, const FileHandler&> ( info, fileHandler );
                    return result;
                }

I have the following compilation error:

error: cannot declare field ‘std::pair<Synchronizer::Info, Synchronizer::ElementHandler>::second’ to be of abstract type ‘Synchronizer::ElementHandler’

How I can write the code to preserve the idea? Is it possible, or I need use pointers and dynamic allocation?

Answer 1

“Avoid dynamic allocation in local scope”.

If that’s the driving need behind your broken code, then I won’t follow the trend by telling you how to fix it to do what you don’t want ;-). Instead, you have to consider the implications properly. You must have some variable with a scope that matches the caller’s needs. Local automatic variables must be ruled out – they are destroyed when the function returns. So, you could:

• use a function scoped static variable, or a global variable, but that will be the same variable each time the function is called and there could be thread-safety issues (your compiler may support some thread-specific keyword, and POSIX has functions to support thread-specific data – but 1-object-per-thread may still be too limiting)
• create some buffer with space for many variables, and take control of their lifetime and reuse in some way that suits the client code (e.g. rotate through an array knowing that the client will release them in the order they’re returned and never need more than the array size concurrently)
• let the client code worry about lifetimes (they probably know more than you) and provide a variable you’re to load with the result (e.g. bool load_my_x(X&);)
  • a problem here is that the caller needs to allocate space for FileHandler and not simply ElementHandler