déclaration de retour avec plus d'un argument

Question

Après avoir compilé mon code C avec -Wall activé, les avertissements suivants figuraient

left operand of comma operator has no effect 

qui sont liés aux multiples arguments présentés dans mes return déclarations. L'histoire est la suivante: Supposons que vous ayez un tas de tableaux 3D alloués dynamiquement (A, B et C) et que vous souhaitiez les manipuler. Les tableaux sont définis comme pointeur vers pointeur sur pointeur et alloués en utilisant malloc (la procédure standard). La manipulation d'entre eux se produira dans des fonctions distinctes. Pour une raison quelconque, je déclare la fonction en tant que pointeur triple et comme suit:

***func(double ***A, double ***B, double ***C) 
{ 
    do some work here on A, B and C 
    return(A, B, C); 
} 

Je sais que les réseaux passent dans la fonction référence pour l'essentiel il n'y a pas besoin de retourner quelque chose de cette fonction. Mais, pouvez-vous me dire pourquoi quelqu'un déclarerait une fonction de cette façon. Ce personnel me confond. Merci à l'avance

Answer 1

return(A, B, C) is not C, vous pouvez utiliser un struct pour renvoyer plusieurs arguments.

struct array3d{ 
    double* A; 
    double* B; 
    double* C; 
}; 

struct array3d* func(struct array3d* p) { 
    /* do some work here on p->A, p->B and p->C */ 
    return p; 
} 

Voici un exemple de travail avec *** pointeurs:

#include <stdio.h> 
#include <malloc.h> 

struct array3d { 
    double*** A; 
    double*** B; 
    double*** C; 
}; 

struct array3d* func(struct array3d* p) { 
    /* do some work here on A, B and C */ 

    ***p->A /= 42.0; 
    ***p->B /= 42.0; 
    ***p->C /= 42.0; 

    return p; 
} 

int main() 
{ 
    struct array3d arr; 
    struct array3d* p_arr; 

    double A[] = { 1.0, 3.0}; // ... 
    double B[] = {-1.0, -2.0}; 
    double C[] = { 2.0, 4.0}; 

    double* p1A = A; 
    double* p1B = B; 
    double* p1C = C; 

    double** p2A = &p1A; 
    double** p2B = &p1B; 
    double** p2C = &p1C; 

    arr.A = &p2A; 
    arr.B = &p2B; 
    arr.C = &p2C; 

    p_arr = func(&arr); 

    printf("(A = %f, B = %f, C = %f)\n", ***p_arr->A, ***p_arr->B, ***p_arr->C); 

    return 0; 
} 

Answer 2

Le code

***func(double ***A, double ***B, double ***C) 
{ 
    do some work here on A, B and C 
    return(A, B, C); 
} 

est tout simplement faux, même si elle compile:

1. Si la fonction de retour ns tout via ses arguments A, B, et C, il ne devrait pas avoir un type de retour. . I. e, il doit être déclaré retourner void:

   void func(double ***A, double ***B, double ***C) { 
   

2. La syntaxe return(A, B, C) ne fait pas ce que vous pensez. Il ne construit pas une liste, ou passe trois valeurs à return. Au lieu de cela, il évalue l'expression A, rejette sa valeur, évalue B, rejette sa valeur, évalue C, prend la valeur de C comme valeur de l'expression (A, B, C) et renvoie finalement cette valeur à la fonction. (Google "C comma operator" pour plus d'informations.)

3. Si votre fonction est déclarée comme renvoyant void (comme cela devrait probablement l'être), il n'y a tout simplement pas besoin d'une instruction return.