Yet another abstract class issue in C++ with closures

Question 1

Well, hope that my solution is correct: at least it compiles :). I'll leave that as an answer in order to receive additional comments concerning the solution. Thanks again.

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
#include <memory>

using namespace std;

//I need shared_pointers in order to gain the C++ dynamic casting
template <typename T> class Ptr {
    shared_ptr<T> ptr;

    public:
        Ptr(T* obj) : ptr{obj} {};
        Ptr(shared_ptr<T> obj) : ptr{obj} {};

        ~Ptr() {  };

        template <typename U> Ptr<U> Cast();

        T* operator->() const  {return &(*this->ptr);}
        operator T() const { return (*this->ptr); };

};

template <typename T> template <typename U> Ptr<U> Ptr<T>::Cast(){
    return Ptr<U>{dynamic_pointer_cast<U>(ptr)};
};


template <typename T> class opt {
    protected:
        T ret;                
    public:
       ~opt() {};
       virtual int isEmpty() = 0;
       virtual T* getObject() = 0;
       operator T() const { return ret; }; 
};

template <typename T> class oopt : public opt<T> {
    public:
    oopt(T obj) { 
        this->ret = obj; 
    };  
    int isEmpty() { return 1; };
    T* getObject() { return &this->ret; }
};

template <typename T> class eopt : public opt<T> {
    public:
    eopt() { };  //for downcasting matters
    T* getObject() { return nullptr; } //
    int isEmpty() { return 1; };
};

int main(void) {

    Ptr<oopt<int>> u(new oopt<int>(500));
    Ptr<opt<int>> w = u.Cast<opt<int>>();
    cout << (*(w->getObject())) << "\n" ;

    Ptr<opt<int>> none(new eopt<int>());
    w = none.Cast<opt<int>>();
    if ((w->getObject()) == nullptr) {
        cout << "null" << "\n";
    }

    return 1;

}

Question 2

as gcc is the standard compiler around, his errors are not the most clears, even more with C++ than C, so i generally compile everything with both clang and gcc just to be sure. compiled with clang: i've got this with aaronman code, t

clang++ -std=c++11 test.cc                                                                                                                                                                              ~
test.cc:20:20: error: only virtual member functions can be marked 'override'
        ~oopt<T>() override;
                   ^~~~~~~~
test.cc:26:54: note: in instantiation of template class 'oopt<int>' requested here
    function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
                                                     ^
test.cc:19:9: error: constructor for 'oopt<int>' must explicitly initialize the base class 'opt<int>' which does not have a default constructor
        oopt<T>(T obj) { ret = obj; };
        ^
test.cc:26:54: note: in instantiation of member function 'oopt<int>::oopt' requested here
    function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
                                                     ^
test.cc:7:29: note: 'opt<int>' declared here
template <typename T> class opt {
                            ^
2 errors generated.

and this for your first:

clang++ -std=c++11 test2.cc                                                                                                                                                                             ~
test2.cc:20:17: error: only virtual member functions can be marked 'override'
        ~oopt() override;
                ^~~~~~~~
test2.cc:26:54: note: in instantiation of template class 'oopt<int>' requested here
    function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
                                                     ^
1 error generated.

after fixing these errors clang gave me this during linking:

clang++ -o -std=c++11 test2.o -Wall -Werror                                                                                                                                                             ~
test2.o: In function `std::_Function_handler<opt<int> (int), main::$_0>::_M_invoke(std::_Any_data const&, int)':
test2.cc:(.text+0x1a7): undefined reference to `oopt<int>::~oopt()'
test2.o:(.rodata._ZTV4ooptIiE[_ZTV4ooptIiE]+0x10): undefined reference to `oopt<int>::~oopt()'
test2.o:(.rodata._ZTV4ooptIiE[_ZTV4ooptIiE]+0x18): undefined reference to `oopt<int>::~oopt()'
clang: error: linker command failed with exit code 1 (use -v to see invocati

on)

it's not a precise answer, but this could help a lot

Question 3

Ok first get rid of the override and make the destructor virtual (they should always be when inherited). Also the destructor is unimplemented in the base class

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
using namespace std;;

template <typename T> class opt {
    public:
        opt() {};
        virtual ~opt() {};
        virtual int isEmpty() = 0;
        virtual T getObject() = 0;
};

template <typename T> class oopt : public opt<T> {
    private:
        T ret;
    public:
        oopt(T obj) { ret = obj; };
        ~oopt(){};
        int isEmpty() { return 0; };
        T getObject() { return ret; };
};
int main(void) {

    function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };

    return 1;
}

This compiles now. As for the errors you were getting originally I can't say as to where they were coming from since I didn't get them