传递指向在 C++ 中动态定义的内置类型的指针

Question

我想调用一个库的函数（我不能修改）

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

有没有办法即时调用定义int 和char 的函数？

即做类似的事情

function(&1, &'v');

而不是

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

这将大大减少我的代码长度，同时提高可读性。

Answer 1

正如其他人所说，答案是否定的......

你可以通过重载function来模拟它：

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

所以现在你可以写function(1, 'v')

Answer 2

为什么要这样做？ 将变量作为非 const 指针传递表示被调用方打算修改传递的参数，因此它不能是右值。

所以传递一个指向文字的指针是没有意义的（除非它是一个不同的字符串文字）。此外，很明显，您无法确定文字的地址，因为它不可寻址。唯一可能有意义的常量是空指针或指向可寻址内存的绝对地址

Answer 3

是的 - 你可以。

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

只要在函数调用后指针没有被取消引用，它是完全合法的。这是因为它们的临时生命周期等于函数调用所在的完整表达式。

它们可以被函数用来修改数据而不会出现任何问题。

生活example。请注意，未定义功能“功能”。这个例子只是说明这样的函数调用是完全有效的。

注意：这种语法的复杂性是由于某些“C++”安全措施造成的。毕竟传递一个指向未命名数据的指针是你很少做的事情。但这并不意味着这个结构是非法的或 UB。

Answer 4

FISOCPP 的回答很好，但我不喜欢临时创建的方式。

用复合横向语法可以做到这一点：

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

使用临时地址的两种方式都会导致 gcc 在您尝试获取地址时发出警告，尽管它是完美定义的有效代码。

有趣的是，由于复合横向在 C 中具有自动存储而不是在 C++ 中的临时存储，因此如果在 C99 模式下编译甚至不会出现警告。

Answer 5

您可以在 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);
}

上述程序产生

1 f
42 ?
42 %

如你所愿。

这里有一些注意事项：首先，如果您尝试使用重载函数，这将失败，因为 C++ 无法将重载函数推断为函数指针：

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

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

您也许可以使用显式模板参数来解决此问题：

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

或者当然是显式输入函数：

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

其次，为简单起见，call_special 及其助手在值类上玩得又快又松。可能需要做更多工作才能稳健地处理右值、常量值等。

第三，既可以作为值也可以作为指针传递的参数将不起作用。事实上，一般来说，转换可能会让人头疼：

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?

你最好使用一个函数来明确地获取地址：

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

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

请注意，无论您使用哪种方法，您都将处理临时对象，它们以分号结尾。因此，如果您使用的库存储了对您给它的参数的引用，那么您别无选择，只能显式地为参数提供存储空间。

Answer 6

可以分配或获取地址的东西是左值。

不能获取地址，也不能分配给 (sortof) 的东西是右值。

这是一个接受右值并将其转换为左值的函数。这个左值只有在源右值有效时才有效，希望它足够长：

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

然后我们按如下方式使用它：

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

as_lvalue 与std::move 的操作大致相反，否则可以称为as_rvalue。并非完全相反，因为我让左值到左值的转换产生了错误。

现在，一元 & 可以重载。所以我们可以这样写：

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

然后调用：

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

如果偏执。