我对双指针作为交换函数的参数有疑问

Question

希望你能帮帮我！我将此函数添加到我的 array.c 中以随机排列数组元素，它适用于 static Item *a;静态暗淡；在我的 array.c.

static Item *a; 
static int dim = 3;

a=malloc( dim * sizeof(Item);

void random_array() {
                                  int i , j;
                                  Item t;
                                  for (i = dim - 1;i > 0; i--)
                                  {
                                      j = rand() % (i + 1);
                                      t = a[i];
                                      a[i] = a[j];
                                      a[j] = t;
                                     //swap(a[i], a[j]);
                                  }
                           }

item.h

typedef void *Item;

项目-int.c

#include <stdio.h>
#include <stdlib.h>
#include "item.h"

Item inputItem(){
    int *p;
    p=malloc(sizeof(int));
    scanf("%d",p);
    return p;
}

void outputItem(Item item){
    int *p;
    p=item;
    printf("%d ",*p);
}

int cmpItem(Item item1,Item item2){
    int *p1,*p2;
    p1 = item1;
    p2 = item2;
    return *p1 - *p2;

}

所以我尝试使用文件 utils.c 中的函数交换 (a[i], a[j]) 但它不起作用。

void swap (Item pa, Item pb) {
    Item t;
    t = pa;
    pa = pb;
    pb = t;
}

它适用于这些指令：

void swap (Item *pa, Item *pb) 
{
    Item t;
    t = *pa;
    *pa = *pb;
    *pb = t;
}

我知道使用“typedef void *Item”，项目 t 就像 void *t 而项目 *a 就像 void **a，对吗？因此，由于 a=malloc(numberelements*(sizeof(Item)); 和 a[i]=malloc(sizeof(Item) 每个指针都指向一个包含许多字节的内存位置，因此使用双指针我有一个包含许多指针的动态数组？

Here a image.

所以对于 t 我不需要 malloc 因为 t = a[i] t 指向从 a[i] 指向的内存位置，对吧？如果是，为什么我必须在交换函数中使用 t = *pa 等而不是 t = pa ？我对双指针作为函数参数有几个疑问。我希望你能解决这个问题。提前致谢！

Answer 1

好的，让我们从这里开始：

typedef int Item;  // Always get this backwards, need to check...

void swap (Item *pa, Item *pb) 
{
    Item t;
    t = *pa;
    *pa = *pb;
    *pb = t;
}

void foo()
{
    Item i= (Item), j=(Item)2;  // These casts are not needed, but help later explanations

    // Must take address so swap can change original values of i and j.
    swap(&i, &j);

    Item *ip = &i;
    Item *jp = &j;

    // This also works because we do the dereference above.
    swap(ip, jj);
}

两者都可以。怎么样？

typedef int******* Item;

void swap (Item *pa, Item *pb) 
{
    Item t;
    t = *pa;
    *pa = *pb;
    *pb = t;
}

void foo()
{
    Item i= (Item)1, j=(Item)2;

    // Must take address so swap can change original values of i and j.
    swap(&i, &j);

    int *ip = &i;
    int *jp = &j;

    // This also works because we do the dereference above.
    swap(ip, jp);
}

同样，类型并不重要。这就是它的使用方式。如果您忘记了 &，编译器会警告您类型不匹配。

我对双指针作为交换函数的参数有疑问

I have doubts about double pointer as parameters for a swap function

c

arrays

pointers

double-pointer