Question

我正在创建一个函数，它接收任何数据类型的数组并反转它的元素。

void f(void *p, int size)
{
  for(int i=0; i<=size/2; i++)
  {
    swap(p+i, p+size-i-1);
  }
}

但问题是如何实现交换其内容的交换函数而不取消引用void指针？

Answer 1

或者您可以使用std :: reverse函数

int main()
{
    int  data[] = { 1, 2, 3, 4, 5, 6, 7};
    std::reverse(data, data + sizeof(data)/sizeof(data[0]));

}

Answer 2

由于您标记为C ++，我假设您可以使用模板。一种可能的解决方案：

template<typename T>
void f(T *p, int size) {
    for(int i=0;i<=size/2;i++) {
        swap(p[i], p[size-i-1]);
    }
}

Answer 3

一个丑陋的C例子，享受它：

#include <stdio.h>

void* f(void * p, size_t blockSize, size_t wholeSize){
    int i;
    unsigned char *begin, *end, temp;

    begin = (unsigned char*) p;
    end = (unsigned char*) p + wholeSize - blockSize;

    while(end>begin){
        for(i=0; i<blockSize; i++){
            temp = begin[i];
            begin[i] = end[i];
            end[i] = temp;
        }
        begin += blockSize;
        end -= blockSize;
    }

    return p;
}

int main()
{
    int i;

    double da[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int ia[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    char ca[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    f(da, sizeof(da[0]), sizeof(da));
    f(ia, sizeof(ia[0]), sizeof(ia));
    f(ca, sizeof(ca[0]), sizeof(ca));

    for(i=0; i<10; i++){
        printf("da[%d]=%lf ia[%d]=%d ca[%d]=%d\n", i, da[i], i, ia[i], i, (int)ca[i]);
    }

    return 0;
}

Answer 4

如果您使用C ++，那么为什么不使用template s：

template<typename T>
void f(T* const p,int size)  // return changed to `void`
{
  // same logic
}

这会为您传递的任何类型（例如f，int[]，char[]）创建此函数A[]的副本。如果您需要，仍可以改进上述功能：

template<typename T, int size>
void f(T (&p)[size])  // don't have to pass sizeof array explicitly
{
  // same logic
}

用法：

int a[] = { ... };
f(a);

Answer 5

你不能这样做。您至少需要数组中一个元素的大小。

或者如果它不是C而是C ++，你可以将该函数作为模板。

Answer 6

void swap(void *a, void *b, size_t size) {
  char buf[size]; //can be malloc if size to too big

  memcpy(temp, b,    size);
  memcpy(b,    a,    size);
  memcpy(a,    temp, size);
}

如何交换void指针的内容？

6 个答案: