Re: Extension methods c++0x
german diago wrote:
On 23 dic, 20:19, Felipe Magno de Almeida <felipe.m.alme...@gmail.com>
wrote:
On Dec 22, 3:38 pm, german diago <germandi...@gmail.com> wrote:
Hello. I've been reading c++0x proposals and I'd like to see a
proposal for c#-like extension methods. Extension methods let
programmers write new methods and use it as if they were class methods
from outside the class. I know it's sintactic sugar, but it makes code
far more readable. As an example:
string str = " hello , world !!!";
to_upper(split(trim_left(str), '<')[0]));
could be written as
str.trim_left().split('<')[0].to_upper();
..
Maybe even changing it to use operator overloading instead of member
functions? This would greatly increase extensability.
str <= (trim_left() >> split('<'))[0] >> to_upper();
..
A first very preliminar implementation is here. The idea is to be able
to wrap algorithms so that they work
with operator- for certain classes.
Using operator- seems a bad idea, but for a proof of concept I suppose
it's ok.
This is a proof of concept. Take a
look at the code. I have some problems. Please read
the comments in the code and if anyone can help... Thanks!!
#include <string>
#include <boost/algorithm/string.hpp>
#include <boost/function.hpp>
#include <iostream>
#include <vector>
//I want this function to return an arbitrary type
template <class klass, class UnaryFunction>
klass &
operator-(klass & object, UnaryFunction f)
{
return f(object);
}
An unconstrained template operator? That seems a very bad idea.
//but if I do like this:
//template <class ResultType, class klass, class UnaryFunction>
//RetType & operator-(klass & object, UnaryFunction f)
//{
// return f(object);
//}
//The function above is not found. It finds another overload instead
of this.
//I'd like to be able to return anything. I can't use boost::enable_if
for overloading
//because operator- must take 1 or 2 arguments. Found a solution? Tell
me.
You can use enable_if on the return value, but that won't help you
here. The problem is that the compiler has no way of deducing what
RetType is. (It won't look in the definition for deduction.) Have a
look at (boost/tr1)::result_of. A better resolution will be decltype,
but that isn't generally available yet.
struct trim_left
{
std::string & operator()(std::string & str)
{
boost::trim_left(str);
return str;
}
};
//Simplified a lot. Proof of concept.
struct split
{
const char * c_;
split(const char * c) : c_(c) {}
std::vector<std::string> operator()(std::string & str)
{
std::vector<std::string> vec;
boost::split(vec, str, boost::is_any_of(c_));
return vec;
}
};
//Macros to extend classes with certain algorithms. This will generate
the boilerplate code above.
//The library will be used with these macros.
#define EXTENSION_METHOD(classextended, algorithm) //TODO
#define EXTENSION_METHOD1(classextended, algorithm, arg1type) //TODO
#define EXTENSION_METHOD2(classextended, algorithm, arg1type,
arg2type) //TODO
//An example!!!
int main()
{
std::string str = " Hello, world!!!";
//This works!!!
str-trim_left();
//This one does not work. The return type for split is a vector (to
simplify, at this moment)
//But I can't overload operator-
//str-trim_left()-split("<");
std::cout << str << std::endl;
}
I would suggest writing a separate operator- for each function type.
You will then have another problem: your operator- takes a non-const
reference as its first parameter, but you're going to need to pass an
rvalue to it. Since rvalue-references are not yet generally available,
your best bet may be to take a const reference. Perhaps overload on
const.
Yechezkel Mett
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]