Question

我调用这样的函数：

void do_work(void* ptr, size_t size)
{
    //do things with ptr and size
}

问题是：是否可以像do_work(one);那样调用函数并以某种方式获取函数内的sizeof？

鉴于one 是静态数组（int one[10];）或非数组（int one;），现在可以吗？

Answer 1

在C ++中，您可以使用模板参数推导来获取指针的类型（指向的类型），然后计算其sizeof：

template<typename T>
void do_work( T* ptr )
{
    constexpr std::size_t size = sizeof(T);
}

Answer 2

不，不是void *，您将无法计算传递地址的对象的大小。

Answer 3

您可以使用功能模板：

template <typename T>
void do_work(T* stuff)
{
  const size_t s = sizeof(T);
  ....
}

编辑：数组版本：

template<typename T, size_t N >
void do_work(T (&array)[N] )
{
  const size_t s = N * sizeof(T);
}

Answer 4

template<typename T>
void do_work(T* ptr)
{
    size_t size = sizeof(T);
    size = sizeof(*ptr); // or this
}

Answer 5

template <typename T>
void do_work(T * t) { do_work(t, sizeof(T)); }

Answer 6

我不知道C ++，这个问题出现在我面前，可能是因为它以前有过C标签。但是你可以在C语言中做到这一点，可能还有C ++：

#define do_work(_a_) do_work_func(_a_, sizeof(_a_))

void do_work_func( void* ptr, size_t size )
{
    //do things with ptr and size
}

考虑到one调用中的do_work( one );被定义为数组，哪个会有用。

Answer 7

如果我找到了你，你可能想要：

#include <iostream>

void do_work(void* ptr, size_t size)
{
    std::cout << "Size: " << size << '\n';
}

template <typename T>
void do_work(T& single) {
    do_work(&single, 1);
}

template <typename T, std::size_t N>
void do_work(T (&array)[N]) {
    do_work(array, N);
}

template <typename T>
void do_work(T* multiple, std::size_t n) {
    do_work(static_cast<void*>(multiple), n);
}

int main()
{
    int a = 1;
    int b[] = { 1, 2, 3 };
    int* c = b;
    do_work(a);
    do_work(b);
    do_work(c, 3);
}

注意：为什么无效*？

是否有可能从函数中获取sizeof？

7 个答案: