Re: Templated Casting operators

From:

Narinder <narinder.claire@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sat, 9 Jul 2011 22:01:30 -0700 (PDT)

Message-ID:

<6def1a38-0e27-4b1d-b3cc-9d8231b08569@t9g2000vbv.googlegroups.com>

On Jul 10, 5:39 am, Narinder <narinder.cla...@gmail.com> wrote:

On Jul 10, 12:15 am, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

Narinder wrote:

On Jul 9, 12:34 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

Narinder wrote:

On Jul 8, 11:06 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
At the moment, I don't see why.

That is indeed curious.
However on my issue, I think I am expecting something from C++ .. =

when

I obviously should know better, "C++ (101): C++ doesn't dispatc=

h on

the return type".

That, I think, is not the entire picture. There is clause [14.8.2.3]=

that

deals with deducing template arguments for templated conversion
operators. Here, the result type desired by the conversion is taken =

into

account. Howerver, reading that clause, I find it hard to tell wheth=

the deduction should fail because of ambiguity, whether the const ve=

rsion

should be instantiated, or whether the non-const version should be
chosen.

My question stems from wanting to pass parameters to a function vi=

a an

intermediary which holds references to the values to be passed. An=

this would be done at runtime.

Given :

void f( double x);

I want to be able to do:

const double x=3.142;
intermediary v = x; // so v will hold a
std::tr1::reference_wrapper<const double>
f(v); // I suspect gcc will complain b=

ecause v is unable

to give up its const ref
// but as we have seen gcc calls operator
double&()

Hm, the following compiles:

#include <iostream>

void foo ( double arg ) {
std::cout << arg << "\n";

}

template < typename T >
class reference_wrapper {

T* the_ptr;

public:

typedef T type;
typedef T& reference;

reference_wrapper ( reference t_ref )
: the_ptr ( &t_ref )
{}

operator reference ( void ) {
return ( *the_ptr );
}

reference get ( void ) {
return ( *the_ptr );
}

};

int main ( void ) {
double const pi = 3.14159;
reference_wrapper< double const > x = pi;
foo( x );

}

My way around this will be to have the user provide a precise boos=

typelist embodying the function signature:

boost::mpl::vector<double>

and use this to dispatch correctly.

Huh?

Best,

Kai-Uwe Bux

Consider the following functions:

f_ref(double&) // may be a member function=

that keeps the

rw ref
f_const_ref(const double&) // maybe a memeber function that keeps =

the

ro ref
f_val(double) // expects the value byval

you have one 'variant'

variant v = 3.142;

double x=3.142;
variant v2 = x;

const double xx=3.142
variant v3 = 3.142

I want to deliver (since it doesn't have to be done by casting) v2 to
f_ref, but not v & v3
I want to deliver v2 & v3 to f_const_ref but not v
and i want to be able to deliver all of them to f_val

Moreover my variants will be initialised at runtime.

I have sketched (but compiles and executes ) what I think is a
solution.
(I have used boost::mpl::vector to be able to generalise to more than
one parameter)

-------------------------------
#include<iostream>
#include<boost/ref.hpp>
#include<boost/variant.hpp>
#include<boost/mpl/vector.hpp>
#include<boost/mpl/at.hpp>

using namespace std;

double pi = 3.142;
typedef boost::reference_wrapper<double> ref;
typedef boost::reference_wrapper<const double> const_ref;

struct klass
{
    klass(double & x):innerVariant(boost::ref(x)){}
    klass(const double & x):innerVariant(boost::cref(x)){}

    template<class T>
    operator T& ()
    {
        cout << " ... casting to double& ";
        return boost::get<ref>(innerVariant);
    }

    template<class T>
    operator const T&()
    {
        cout << " ... casting to const double& ";
        if(boost::get<ref>(&innerVariant))
        {
            return boost::get<ref>(innerVariant);
        }
        return boost::get<const_ref>(innerVariant);

    }

    const double &get_by_val()
    {
        return (const double&)(*this);
    }

private:
    boost::variant<ref,const_ref > innerVariant;
};

template<class T,class U>
struct innerCast
{
    static const T & get(U &k)
    {
        return k.get_by_val();
    }
};

template<class T,class U>
struct innerCast<T&,U>
{
    static T & get(U &k)
    {
        return k;
    }
};

template<class T,class U>
struct innerCast<const T&,U>
{
    static const T & get(U &k)
    {
        return k;
    }
};

template<class T>
struct cast
{
    typedef typename boost::mpl::at_c<typename T::param_type,0>::=

type

ret_type;

    static ret_type get(klass &k)
    {
        return innerCast<ret_type,klass>::get(k);
    }

};

/////////////////////////////////////////
// Below is what would be the user code
/////////////////////////////////////////

struct f
{
    typedef boost::mpl::vector<double&>::type param_type;
    static void call(double &x)
    {
        cout << " double &x\n";
    }
};

struct fc
{
    typedef boost::mpl::vector<const double&> param_type;
    static void call(const double &x)
    {
        cout << " const double &x\n";
    }
};

struct ft
{
    typedef boost::mpl::vector<double> param_type;
    static void call(double x)
    {
        cout << " double\n";
    }

};

int main()
{

    try
    {

        double x(3.142);

        klass k_non_const(x);
        klass k_const(3.142);

        f::call( cast<f>::get(k_non_const) );
        fc::call( cast<fc>::get(k_non_const));
        ft::call( cast<ft>::get(k_non_const));

        fc::call( cast<fc>::get(k_const));
        ft::call( cast<ft>::get(k_const)); // this one *NO LO=

NGER*

throws with gcc
    }
    catch(const std::exception &err)
    {
        cout << err.what() << "\n";
    }

}

---------------------------------------------

Maybe some of the class names have alot of scope to be more
meaningful :-)

Here is an alternative idea (hopefully, I understood your aim):

#include <iostream>

struct oops {};

template < typename T >
class const_reference {

  T const * ptr;

public:

  const_reference ( T const & r )
    : ptr ( &r )
  {}

  T const & get ( void ) {
    return ( *ptr );
  }

  operator T const & ( void ) {
    return ( *ptr );
  }

};

template < typename T >
class reference {

  T * ptr;

public:

  reference ( T & r )
    : ptr ( &r )
  {}

  T & get ( void ) {
    return ( *ptr );
  }

  operator T & ( void ) {
    return ( *ptr );
  }

};

template < typename T >
class wrapper {
private:

  T * the_ptr;
  T const * the_c_ptr;

public:

  wrapper ( T & ref )
    : the_ptr ( &ref )
    , the_c_ptr ()
  {}

  wrapper ( T const & cref )
    : the_ptr ()
    , the_c_ptr ( &cref )
  {}

  operator reference<T> ( void ) {
    std::cout << "non-const\n";
    if ( the_ptr ) {
      return ( *the_ptr );
    }
    throw ( oops() );
  }

  operator const_reference<T> ( void ) {
    std::cout << "const\n";
    if ( the_ptr ) {
      return ( *the_ptr );
    }
    return ( *the_c_ptr );
  }

  operator T ( void ) {
    if ( the_ptr ) {
      return ( *the_ptr );
    }
    return ( *the_c_ptr );
  }

};

double const pi = 3.14159;
double e = 2.71828;

typedef wrapper< double > klass;

void foo_ref ( reference<double> ) {
  std::cout << "reference\n";

}

void foo_cref ( const_reference<double> ) {
  std::cout << "const reference\n";

}

void foo_val ( double ) {
  std::cout << "value\n";

}

int main ( void ) {
  klass rw ( e );
  klass ro ( pi );
  foo_val( rw );
  foo_cref( rw );
  foo_ref( rw );
  foo_val( ro );
  foo_cref( ro );
  foo_ref( ro );

}

Best,

Kai-Uwe Bux

In my case the functions foo_ref, foo_cref, foo_val will be given (by
the client) and may ( and most probably will) be compiled without any
knowledge of the types reference and const_reference. So I would need
it to work with :

--------------------------
void foo_ref ( double & ) {
  std::cout << "reference\n";

}

void foo_cref ( const double & ) {
  std::cout << "const reference\n";

}

void foo_val ( double ) {
  std::cout << "value\n";}

--------------------------

(In fact to be even more precise, in my real scenario they will be
class constructors.)
When I compile your code with above modifications I get the
compilation error:

-------------------------------------------------
main/main.cpp: In function 'int main()':
main/main.cpp:93:15: error: invalid initialization of reference of
type 'double&
' from expression of type 'klass'
main/main.cpp:72:6: error: in passing argument 1 of 'void
foo_ref(double&)'
main/main.cpp:96:15: error: invalid initialization of reference of
type 'double&
' from expression of type 'klass'
main/main.cpp:72:6: error: in passing argument 1 of 'void
foo_ref(double&)'
------------------------------------------------

Best
N

...also if I make the following amendments :

------------------------------------

.....
struct someClass
{
    someClass(const double &x_):x(x_){}
    void show()const{std::cout << "x=" <<x <<"\n";}
    const double &x;
};

int main ( void ) {

  double const pi = 3.14159;
  double e = 2.71828;

  klass rw ( e );
  klass ro ( pi );
  foo_val( rw );
  foo_cref( rw );
// foo_ref( rw );
  foo_val( ro );
  foo_cref( ro );
// foo_ref( ro );

  someClass s(rw);
  s.show();
  e=0.0;
  s.show();
}

-------------------------

It doesn't work as expected, specifically the last s.show() display 0.

Best N