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;                                                                                                                             
}

在这里进行所有解除引用时,保留两个本地指针甚至只是索引可能是有意义的,并在循环结束时设置一次返回值.

[编辑]

为什么我不能在函数中更改指针？如果我改为发送一个数组(像指针一样的东西)来保留最小值和最大值,比如minmax [0] = min和minmax [1] = max,那么值会改变,不是吗？

好吧,有点,但是你要求指向数组元素的指针是min和max,而不是实际值.所以,即使你传递一个数组来实现它,它也必须是一个指针数组(double *minmax[2]).现在,这实际上只是double**指向两个double*值(分别为元素0和1).所以这是一回事.

现在,为什么你不能改变指针？您可以!但是您的更改仅限于您的函数范围内.您无法在调用者处更改该值,因为double*指针是按值传递的.在我让你感到困惑之前,你可能需要对传值和传递引用进行一些阅读,但总体思路是这样的:

您发送到函数的任何数据类型都会被有效复制.因此,如果您传递a 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

每当您提供指向要由函数更改的值的指针时,它都被称为通过引用传递.