c - 传递指向函数的指针

Question

我正在尝试更改指针 min 和 max 指向的位置，但似乎“更改”并未超出函数范围(在函数运行后)。在运行该函数之前，我将 *min 和 *max 设置为指向“double m = 0”。我有点像 NOOB，所以任何建议都将不胜感激。

int min_max(double * min , double * max , int size , double a[]){                                                                       
int i;                                                                                                                                

printf("\n%lg\t%lg\n", *min, *max);                                                                                                   

min = &a[0];                                                                                                                          
max = &a[0];                                                                                                                          

for (i = 1 ; i < size ; i++) {                                                                                                        
 if (a[i] > *max)                                                                                                                    
  max = &a[i];                                                                                                                      
 else if (a[i] < *min)                                                                                                               
  min = &a[i];                                                                                                                      
 }                                                                                                                                     
 printf("\n%lg\t%lg\n", *min, *max);                                                                                                   
 return 0;                                                                                                                             
}

Answer 1

如果您发送一个指向 double 的指针，则您允许更改该 double 的内容。如果你想让指针改变，你必须发送一个指向指针的指针(double**)，这允许指针的内容改变。

int min_max(double ** min , double ** max , int size , double a[]){  
    int i;                                                                                                                                

    printf("\n%lg\t%lg\n", **min, **max);                                                                                                   

    *min = &a[0];                                                                                                                          
    *max = &a[0];                                                                                                                          

    for (i = 1 ; i < size ; i++) {                                                                                                        
        if (a[i] > **max)                                                                                                                    
            *max = &a[i];                                                                                                                      
        else if (a[i] < **min)                                                                                                               
            *min = &a[i];                                                                                                                      
    }                                                                                                                                     
    printf("\n%lg\t%lg\n", **min, **max);                                                                                                   
    return 0;                                                                                                                             
}

由于此处进行了所有取消引用，因此保留两个本地指针或什至仅保留索引可能有意义，并在循环结束时设置一次返回值。

[编辑]

Why is it that I can't change a pointer in a function? If I instead send an array (a pointer like thing) to retain the min and max values, say, minmax[0]=min, and minmax[1]=max, the values will change, no?

嗯，有点，但是您要的是指向数组元素的指针，即最小值和最大值，而不是实际值。因此，即使您通过一个数组来实现这一点，它也必须是一个指针数组 (double *minmax[2])。现在，这实际上只是一个 double** 指向两个 double* 值(您分别索引为元素 0 和 1)。所以这是一回事。

现在，为什么不能更改指针？你可以!但是您的更改仅限于您的功能范围内。您不能在调用者处更改值，因为double* 指针是按值传递的。在我让您感到困惑之前，您可能需要阅读一些关于按值传递和按引用传递的内容，但总体思路是这样的:

您发送给函数的任何数据类型都会被有效复制。因此，如果您传递一个 double，该值将从调用者复制到一个新的内存位置(函数的一个参数)。该函数现在没有引用该值的原始位置。

void my_func( double val ) {
    val = 42;  // Does not affect caller's value because it was copied
}

double value = 1;
my_func( value );
// value is still 1

传递 double* 时也是如此。您正在向函数发送一个 double 值的地址，但实际地址(指针)是一个复制到 double* 中的值> 提供给您的功能。

void my_func( double* val ) {
    *val = 42;  // Stuff 42 into the memory location pointed to by 'val'.
}

double value = 1;
my_func( value );
// value is now 42

但是您的调用者似乎想要最大值和最小值数组中的实际地址(除非这是由于不熟悉指针而导致的错误)。在那种情况下，指针是不够的，因为您正在复制指针的内容。在这里，您需要获取保存指针的内存地址并将其传递给函数。该地址被复制，当您引用它时，您可以将指针写入该内存位置。

void my_func( double** val ) {
    *val = *val + 1;  // Change the pointer pointed to by 'val'.
}

double values[4] = { 1, 2, 3, 42 };
double *value = &values[2];         // value points to '3'.
my_func( &value );
// value now points to 42

每当您提供一个指向您希望由函数更改的值的指针时，它被称为按引用传递。