Initializing and assigning values,from pass by reference

Question

Okay, this is just a minor caveat. I am currently working with the lovely ArcSDK from ESRI. Now to get a value from any of their functions, you basically have to pass the variable, you want to assign the value to.

E.g.:

long output_width;
IRasterProps->get_Width(&output_width);

Its such a minor thing, but when you have to pick out around 30 different pieces of data from their miscellaneous functions, it really starts to get annoying.

So what i was wondering is it possible to somehow by the magic of STL or C++ change this into:

long output_width = IRasterProps->get_Width(<something magical>);

All of the functions return void, otherwise the off chance some of them might return a HRESULT, which i can safely ignore. Any ideas?

*EDIT**

Heres the final result i got which works :)!!!!!

A magic(P p, R (__stdcall T::*f)(A *)) {
    A a;
    ((*p).*f)(&a);
    return a;
}

Answer 1

Don't think this is possible. Assigning void to a long should be an error in any case.

Remember, it's probably more performant to pass-by-reference than to return a large object. (won't really make a difference with long's though)

Compiling this:

void foo(long &a) {
}

    int main(void) {

    long a=0;
    a = foo(a);
    return 0;
}

gives this error:

g++ x.cc 
x.cc: In function ‘int main()’:
x.cc:9: error: void value not ignored as it ought to be

Answer 2

This is not quite what you specified because you need to wrap get() around the method, but it works:

template<class T, class S>
T get(S fun(T&)) {
  T result;
  fun(result);
  return result;
}

void foo(int& x) {
  x = 5;
}

bool bar(char& x) {
  x = 'c';
  return false;
}

int main() {
  int x = get(foo);
  char y = get(bar);

  return 0;
}

Answer 3

I'm not aware of something insane you could do, precisely like you're asking, and if there was some insane hackery that did work on some peculiar platform I'm pretty sure in a code-review I'd hate it.

It may may more sense to either...

• define some trivial inline function wrappers around the APIs you care about

• make a specialized class descend from IRasterProps (or whatever) that provides the appropriate accessor methods.

Either of those will impact maintenance time of the code but would safely and cleanly give you the call syntax you are looking for.

Answer 4

EDIT: In retrospect, I'm not sure this one will actually work, since I don't think the template arguments will deduce. Buyer Beware.

Sure! What you need is something to which you can pass a function that will call it and return you the outputted value.

Here's the easy, if less efficient way:

template <typename T>
T magic(boost::function<void(T&)> f) {
    T x;
    f(x);
    return x;
}

Which you'd then call like this using boost::lambda:

long output_width = magic(raster_props_object->*&IRasterProps::get_Width);

Or like this, using boost::bind:

long output_width = magic(bind(&IRasterProps::get_Width, raster_props_object, _1));

You can get rid of boost::function, but that's uglier. Probably worth it, though.

Answer 5

Can you derive from IRasterProps? Being that the case you can construct your own interface to it.

EDIT: Following on the concept you can probably also apply the Adapter design pattern (or even a Facade if you wish to apply a common interface to several like-minded classes of the SDK).

Answer 6

I know I've already answered, but here's another way. It's better in that it's faster (no boost::function overhead) and avoids the binders (since people seem to have an aversion to them), but is worse in that it's much less general (since it only works for one-argument member functions).

template <typename P, typename T, typename A>
A magic(P p, void (T::*f)(A &)) {
    A a;
    ((*p).*f)(a);
    return a;
}

Which you'd call like this:

long output_width = magic(raster_props_object, &IRasterProps::get_Width);

Or, if you happen to be using GCC, we can use some more tricks:

#define MORE_MAGIC(p,f) ({ \
    typedef __typeof(*(p)) big_ugly_identifier; \
    magic((p),(&big_ugly_identifier::f)); \
})

Which will let us do this:

long output_width = MORE_MAGIC(raster_props_object, get_Width);

(Bonus points if the naming conventions made you think of a PDP-10.)

EDIT: Updated to take any pointer-like type, so it will now work with shared_ptr, iterators, and hopefully _com_ptr.

EDIT: Oops, they're pointers, not references. Here's a version (or overload) that deals with that, and allows -- by ignoring -- arbitrarily-typed return values.

template <typename P, typename T, typename A, typename R>
A magic(P p, R (T::*f)(A *)) {
    A a;
    ((*p).*f)(&a);
    return a;
}

Answer 7

Looks like a COM object to me. Visual C++ supports an #import directive to import the type library, and create high-legel wrappers. So you either end up with

width = ptr->GetWidth();

or - even better -

width = ptr->Width;

If a function fails, the HRESULT returned will be transformed into an _com_error exception.

I've used that successfully on many OS and 3rd party COM objects, makes them much easier to use.

Note that you control the wrapper generation through options, the first thing I do is usually adding a rename_namespace or no_namespace, because otherwise the symbold end up in a namespace depending on the typelib name, which is usually ugly.

also, unless you use named_guids option, you might needto change CLSID_xxx and IID_xxx constants to __uuidof(xxx).