passing a pointer to a built-in type defined on the fly in c++

Question

I want to call a function of a library (that I can not modify)

void function(int* i, char* c);

Is there a way to call the function defining the int and the char on the fly?

i.e. doing something like

function(&1, &'v');

instead of

int int_1 = 1;
char char_1 = 'v';
function(&int_1, &char_v);

This would enormously decrease the length of my code while increasing readability.

Answer 1

As others have noted, the answer is no...

You could simulate it by overloading function :

void function(int i, char c)
{
  function(&i, &c);
}

So now you can write function(1, 'v')

Answer 2

Why would you want to do so? Passing a variable as a non const pointer indicates that the callee intends to modify the parameter that is passed therefore it cannot be an rvalue.

So passing a pointer to a literal would be meaningless (unless it is a string literal which is different). Moreover as it is obvious to you, you cannot determine an address of a literal as it is not addressable. The only constant that could be meaningful is a null pointer or some absolute address to an addressable memory

Answer 3

Yes - you can.

function((int*)&(const int &)1, (char*)&(const char &)'v');

And it's completely legal as long as the pointers aren't dereferenced after the function call. This is because they have temporary life-time which equals the full expression in which the function call exists.

They can be used by the function to modify the data without any possible issues.

Life example. Note that the function 'function' isn't defined. The example only demonstrates that such function call is completely valid.

Note: The complexity of this syntax is due to some 'C++' security measures. After all passing a pointer to unnamed data is something you do rare. However this doesn't mean that this structure is illegal or UB.

Answer 4

FISOCPP's answer is nice, but I don't like the way temporary is created.

It can be done this way with compound lateral syntax:

function(&(int){1}, &(char){'v'});

Both ways that uses temporary cause gcc to emit warnings when you try to take the address, although it's perfectly defined valid code.

Interestingly, as compound lateral has automatic storage in C rather temporary storage in C++, so there won't be even warnings if compiled in C99 mode.

Answer 5

You can make this happen in C++11:

#include <type_traits>
#include <iostream>

template <typename Param, typename Arg>
Param take_address_if_necessary_impl (Arg&& arg, std::true_type, std::false_type)
{
    return arg;
}

template <typename Param, typename Arg>
Param take_address_if_necessary_impl (Arg&& arg, std::false_type, std::true_type)
{
    return &arg;
}

template <typename Param, typename Arg>
Param take_address_if_necessary (Arg&& arg)
{
    return take_address_if_necessary_impl <Param> (
        arg,
        typename std::is_convertible <Arg, Param>::type {},
        typename std::is_convertible <typename std::add_pointer <Arg>::type, Param>::type {}
    );
}

template <typename Ret, typename... Params, typename... Args>
Ret call_special (Ret (*f) (Params...), Args&&... args)
{
    return f (take_address_if_necessary <Params, Args> (args)...);
}

template <typename... Params, typename... Args>
void call_special (void (*f) (Params...), Args&&... args)
{
    f (take_address_if_necessary <Params> (args)...);
}

void function (int* i, char* c)
{
    std::cout << *i << ' ' << *c << std::endl;
}

int main ()
{
    int i = 42;
    char c = '%';

    call_special (function, 1, 'f');
    call_special (function, &i, '?');
    call_special (function, &i, &c);
}

The above program yields

1 f
42 ?
42 %

as you'd expect.

There are some caveats here: first, this will fail if you try to use an overloaded function, because C++ can't deduce an overloaded function to a function pointer:

void bar (int);
void bar (float);

call_special (bar, 3.0f); // Compiler error

You might be able to fix this with explicit template arguments:

call_special <float> (bar, 3.0f); // Works

Or of course explicitly typing the function:

call_special ((void (*) (float))bar, 3.0f);

Second, for simplicity's sake, call_special and its helpers play fast and loose with value classes. It may need more work to be able to handle rvalues, const values, etc. robustly.

Third, arguments that can be passed both as values and as pointers will not work. In fact, conversions in general are probably going to cause headaches:

void quux (long* i)
{
    if (i)
        std::cout << *i << std::endl;
    else
        std::cout << "(null)" << std::endl;
}

call_special (quux, NULL); // What does this print?

You may be better off using a function to grab the address explicitly:

template <typename T>
T* foo (T&& t)
{
    return &t;
}

function (foo (3), foo ('7'));

Note that whatever method you use, you're going to be dealing with temporaries, which die at the semicolon. So if the library you're using stores a reference to an argument you give it, you have no choice but to explicitly give storage to the argument.

Answer 6

Something that can be assigned to or have its address taken is an lvalue.

Something that cannot have its address taken, nor be assigned to (sortof), is an rvalue.

This is a function that takes an rvalue, and converts it to an lvalue. This lvalue will only be valid as long as the source rvalue was valid, which hopefully is long enough:

template<class T>
T& as_lvalue(T&& t){return t;}
template<class T>
void as_lvalue(T&)=delete;

We then use it as follows:

function(&as_lvalue(1), &as_lvalue('v'));

as_lvalue is roughly the opposite operation of std::move, which could otherwise be called as_rvalue. It isn't completely the opposite, because I made lvalue-to-lvalue conversion generate an error.

Now, unary & can be overloaded. So we can write:

template<class T>
T* addressof_temporary(T&& t) {
  return std::addressof( as_lvalue(std::forward<T>(t)) );
}

then call:

function(addressof_temporary(1), addressof_temporary('v'));

if paranoid.