#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/pop_back.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/variadic/to_seq.hpp>

// Use: NESTED_DECL( boost, asio, ip, udp, class socket; )
// Yields:
//   namespace boost { namespace asio { namespace ip { namespace udp {
//     class socket;
//   } } } }
#define NESTED_DECL( ... )                                                     \
NESTED_DECL_IMPL_SEQ( BOOST_PP_VARIADIC_TO_SEQ( __VA_ARGS__ ) )

#define NESTED_DECL_IMPL_SEQ( seq )                                            \
BOOST_PP_SEQ_FOR_EACH( NESTED_DECL_HAS_NAMESPACE_MACRO, ~                      \
                     , BOOST_PP_SEQ_POP_BACK( seq )                            \
                     )                                                         \
BOOST_PP_SEQ_ELEM( BOOST_PP_DEC( BOOST_PP_SEQ_SIZE( seq ) ), seq )             \
BOOST_PP_REPEAT_FROM_TO                                                        \
( 1, BOOST_PP_SEQ_SIZE( seq ), NESTED_DECL_END_NAMESPACE_MACRO, ~ )

// Macros used during iteration to open and close the namespace
#define NESTED_DECL_HAS_NAMESPACE_MACRO( r, data, elem ) namespace elem {
#define NESTED_DECL_END_NAMESPACE_MACRO( r, data, elem ) }

That Turkey Story fucked around with this message at 00:52 on Jan 31, 2012

class holds_expensive_to_construct
{
public:
    holds_expensive_to_construct(bar * b) 
    : etc(b)
    {
    }

    expensive_to_construct etc;
};

class foo
{
   // ...
   foo(const holds_expensive_to_construct& holder)
   : ndc(holder.etc), se(holder.etc)
   {
   }
};

int main()
{
   bar* b;
   foo f(b);
}

class foo
{
   // ...
   foo(bar* b) : foo(holds_expensive_to_construct(b)) { }
private:
   class holds_expensive_to_construct
   {
      // ...
   };
   foo(const holds_expensive_to_construct&) // etc.
};

Paniolo fucked around with this message at 05:58 on Jan 31, 2012

Foo foo = conversion::convert_string<Foo>(somestring);

chglcu fucked around with this message at 04:10 on Feb 2, 2012

• What if I need an explicit conversion (constructor or conversion function) to get to the context type?
  
• What if I use the result, but it's not the initialization of a variable? What if I just assign it to a variable instead, is that unambiguous enough? What if I do a member access? A qualified member access? What if it's decltype or something?
  
• Even more interestingly, what if I use the result as a call argument? What if it's an overloaded call? What if it's a call to a function template? What if it's a call to a function template whose result might be contextually inferable? What if it's a call that might use argument-dependent lookup?
  
• Which of the previous answers change, if any, if one of the template arguments used in the result type (and therefore potentially inferable) also appears elsewhere in the signature of the function template? How does this interact with ordinary template argument deduction? How much do I have to resolve about the context in order to judge this?
  
• What if the call itself is overloaded? How does this "type context" interact with overload resolution? What are the rules for inferring a type from context? The existing template argument deduction rules mostly deal with the opposite direction of inference.
  

class conversion
{
  struct string_converter
  {
    explicit string_converter( std::string const& str ) : m_str( str ) {}

    template< class T >
    operator T() const
    {
      //Create a stringstream object containing the string passed through
      std::istringstream toConvert(m_str);
      //Create the return type
      T returnType;


      //std::cout << "Attempting to convert "+toConvert.str()+" to "+(std::string)typeid(returnType).name() << std::endl;
      //Attempt to convert the string to the returntype
      if(!(toConvert >> returnType))
      {
        exitWithError("Could not convert to "+(std::string)typeid(returnType).name());
      }

      //If conversion was successful, return the converted string
      return returnType;
    }
  private:
    std::string const& m_str;
  };

public:
  static string_converter convert_string(const std::string &str)
  {
    return string_converter( str );
  }
};

That Turkey Story fucked around with this message at 10:13 on Feb 2, 2012

rjmccall fucked around with this message at 19:48 on Feb 2, 2012

class MyListManager
{
public:
   std::list<Object*>     myObjects;
   std::list<Cheese*>     myCheeses;
};

class Object
{
public:
   virtual void AddToLists(MyListManager* listManager)
   {
      listManager->myObjects.push_back(this);
   }

   virtual void RemoveFromLists(MyListManager* listManager)
   {
      std::list<Object*>::iterator iter=std::find(listManager->myObjects.begin(), listManager->myObjects.end(),this);

      assert(iter!=listManager->myObjects.end());
      listManager->myObjects.erase(iter);
   }
};

class Cheese : public Object
{
public:
   virtual void AddToLists(MyListManager* listManager)
   {
      Object::AddToLists(listManager);

      listManager->myCheeses.push_back(this);
   }

   virtual void RemoveFromLists(MyListManager* listManager)
   {
      Object::RemoveFromLists(listManager);

      std::list<Cheese*>::iterator iter=std::find(listManager->myCheeses.begin(), listManager->myCheeses.end(),this);

      assert(iter!=listManager->myCheeses.end());
      listManager->myCheeses.erase(iter);
   }
}

Gerblyn fucked around with this message at 13:46 on Feb 5, 2012