C++Talk.NET

Guest

This message shows how to make the following code legal C++:

object.set()(Data(1),WithinFoobar(x));

Making C++ look more like the self documenting Objective C. (Though I
think I like having the power of C++ over having the weak typing of
Objective C.)

#include "stdafx.h"
// This program demostrates a way to make strong typedefs in C++. It
is
// unforunate that C++ does not have strong typedef's as well as weak
// typedefs built in. Strong typedefing allow C++ look more like
// Objective C. I would enjoy hearing whether anyone else likes
// this techinque. Of course, some of this might just be considered
// Rube-Goldberg by some, but I really like proxies and the syntax
// of Objective C though I have not programmed in it (just read about
it).
namespace StrongTypedefLibrary
{
// This one allows a constant strong typedef.
template<typename T> class ConstDataReferencer
{
T const& data;
public:
typedef T data_type;
explicit ConstDataReferencer(T const& r) : data(r) {}
T const& get() const { return data; }
};
// This one allows a mutable strong typedef.
template<typename T> class MutableDataReferencer
{
T& data;
public:
typedef T data_type;
explicit MutableDataReferencer(T& r) : data(r) {}
T& get() { return data; }
};
}

// If there were a __UNIQUE__ macro in C++ then a second template
// parameter could be added to the DataReferencer types instead
// of having to encode in the Class, but the Class makes it Unique
// for infix notation but allowing the same parameter names though
// __UNIQUE__ would be better. (Not sure infix is right word here,
// but look at the uses of the operator call for information on what
// I mean.)
#define STRONGTYPEDEF(Class,TYPE,NEWTYPE,DR) \
struct Class { \
typedef StrongTypedefLibrary: Very Happy

R##DataReferencer<TYPE> NEWTYPE; }; \
typedef Class::NEWTYPE NEWTYPE;

// This is a macro that allows the use of one parameter operator calls
// so that parameters may be named like they are named in
// objective C. (Though still a different syntax.)
#define PROXY1(MEMBER,METHOD,TPROXY1) \
class Proxy##METHOD { \
private: TPROXY1::data_type& data; \
public: \
class Proxy##METHOD##Result; \
Proxy##METHOD(TPROXY1::data_type& r) : data(r) {} \
Proxy##METHOD##Result operator()(TPROXY1); \
}; \
Proxy##METHOD METHOD() { return Proxy##METHOD(this->MEMBER); }

// This is a macro that allows the use of two parameter operator calls
// so that parameters may be named like they are named in
// objective C. (Though still a different syntax.)
#define PROXY2(MEMBER1,MEMBER2,METHOD,TPROXY1,TPROXY2) \
class Proxy##METHOD { \
private: \
TPROXY1::data_type& data1; \
TPROXY2::data_type& data2; \
public: \
class Proxy##METHOD##Result; \
Proxy##METHOD(TPROXY1::data_type& d1, TPROXY2::data_type& d2) :
data1(d1), data2(d2) {} \
Proxy##METHOD##Result operator()(TPROXY1, TPROXY2); \
}; \
Proxy##METHOD METHOD() { return Proxy##METHOD(this->MEMBER1,
this->MEMBER2); }

namespace AFineName { class C
{
private:
int first; int second;

public:
C(int f, int s) : first(f), second(s) {}
// Strong typedefs:
STRONGTYPEDEF(InnerDataTypeA, int, FirstInt, Const);
STRONGTYPEDEF(InnerDataTypeB, int, SecondInt, Mutable);

PROXY2(first,second,a,FirstInt,SecondInt);
PROXY1(first,b,FirstInt);
};
// These result classes allow the operator calls to return data.
// It is not possible to have a void operator call (ProxybResult
// is the closest one to NULL as possible.)
class C::Proxya::ProxyaResult {
public:
ProxyaResult const& operator=(ProxyaResult const&)
{ std::cout << "ProxyaResult" << std::endl; return *this; }
};
class C::Proxyb::ProxybResult { };

C::Proxya::ProxyaResult C::Proxya::operator ()(C::FirstInt fi,
C::SecondInt si)
{
data1 = fi.get();
data2 = si.get()++;
return ProxyaResult();
}

C::Proxyb::ProxybResult C::Proxyb::operator ()(C::FirstInt fi)
{
data = fi.get();
return ProxybResult();
}
}

int _tmain(int argc, _TCHAR* argv[])
{
AFineName::C area(1,2);
int second = 13;
AFineName::C::Proxya::ProxyaResult result;

{ using namespace AFineName;
// Is this not pretty syntax:
result = area.a()(C::FirstInt(10),C::SecondInt(second));
// And this too:
area.b()(C::FirstInt(201));
}
// Will be 14.
std::cout << second << std::endl;
return 0;
}
// Sincerely, Mark Barkell 2006 AD June 11. 2:49 AM

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Guest

It can be even nicer than