Hello,
I'm wondering if it would be appropriate to treat the fundamental types
(char, short, int, double, ...) by value, by default.
I wrote this simple piece of code.
I'm not sure if I'm leaving without considering any other implication, but
I think it may be an improvement.
Please, tell me if I am wrong.
Thanks and regards,
Fernando Pelliccioni.
//BEGIN CODE
******************************************************************************************
#include <boost/proto/proto.hpp>
namespace math
{
template <typename T>
struct dynamic_matrix
{
dynamic_matrix(std::size_t x_lenght, std::size_t y_lenght)
{
//...
}
//Expensive Copy Constructor!!
//...
};
} // namespace math
using namespace boost;
//---------------------------------------------------------------------------------------------------------
#define BOOST_PROTO_DEFINE_BINARY_OPERATOR_PRIMITIVE(OP, TAG, TRAIT,
DOMAIN, PRIMITIVE) \
template<typename Left>
\
BOOST_FORCEINLINE
\
typename boost::proto::detail::enable_binary<
\
DOMAIN
\
, DOMAIN::proto_grammar
\
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, PRIMITIVE)
\
, TAG
\
, Left const &
\
, PRIMITIVE
\
>::type const
\
operator OP(Left &&left, PRIMITIVE right)
\
{
\
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &,
PRIMITIVE>()(left, right); \
}
\
template<typename Right>
\
BOOST_FORCEINLINE
\
typename boost::proto::detail::enable_binary<
\
DOMAIN
\
, DOMAIN::proto_grammar
\
, BOOST_PROTO_APPLY_BINARY_(TRAIT, PRIMITIVE, Right)
\
, TAG
\
, PRIMITIVE
\
, Right const &
\
>::type const
\
operator OP(PRIMITIVE left, Right &&right)
\
{
\
return boost::proto::detail::make_expr_<TAG, DOMAIN, PRIMITIVE, Right
const &>()(left, right); \
}
/**/
//---------------------------------------------------------------------------------------------------------
namespace math
{
template <typename T>
struct is_terminal
: mpl::false_
{};
template <typename U>
struct is_terminal<dynamic_matrix<U> >
: mpl::true_
{};
BOOST_PROTO_DEFINE_OPERATORS(is_terminal, proto::default_domain)
BOOST_PROTO_DEFINE_BINARY_OPERATOR_PRIMITIVE(*,
boost::proto::tag::multiplies, is_terminal, proto::default_domain, int)
} //namespace math
int main( /* int argc, char* argv[] */ )
{
using math::dynamic_matrix;
dynamic_matrix<int> m1(5, 5); //define the x and y size of the
matrix
dynamic_matrix<int> m2(5, 5);
auto e = m1 + m2; // m1 and m2 are held by reference
auto e2 = m1 * m2; // m1 and m2 are held by reference
auto e3 = m1 * 5; // m1 is held by reference. 5 is
held by value - NO dangling references
auto e4 = proto::deep_copy(m1 * m2); // Expensive copy of m1 and m2
auto e5 = proto::deep_copy(m1 * 5); // Expensive copy of m1
auto e6 = m1 + m2 * 5; // m1 and m2 are held by
reference. 5 is held by value - NO dangling references
auto e7 = m1 + m2 + dynamic_matrix<int>(5, 5); //dangling reference - I
don't care - Needed deep_copy
return 0;
}
//END CODE
******************************************************************************************
_______________________________________________
proto mailing list
proto@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/proto
