4

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

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

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

即做类似的事情

function(&1, &'v');

代替

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

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

4

6 回答 6

7

正如其他人所指出的那样，答案是否定的......

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

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

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

于 2015-04-21T16:39:47.757 回答
3

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

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

于 2015-04-21T16:33:03.280 回答
2

是的你可以。

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

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

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

生活榜样。请注意，未定义功能“功能”。该示例仅说明此类函数调用是完全有效的。

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

于 2015-04-21T16:47:13.713 回答
0

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

可以使用复合横向语法以这种方式完成：

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

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

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

于 2015-04-21T17:27:56.877 回答
0

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

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

于 2015-04-21T18:02:51.230 回答
0

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

不能获取地址，也不能分配给（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'));

如果偏执。

于 2015-04-21T21:22:41.500 回答