c/C++ | int * excepté, int donné (renvoyant un pointeur ??)

Question

Donc je fais un programme pour trouver la plus grande soustraction possible. Si n est, f.e 9284, le nombre minimum qui peut être fait avec les chiffres de 9284 est 2489 et le maximum est 9842. La fonction max_substraction renvoie 9842 - 2489 en sortie.

Le problème est que chaque fois que j'exécute le programme et tapez un nombre, le programme se bloque. J'ai essayé de déboguer et on m'a dit que la fonction "to_digits" était excepté int * mais int donné ce qui est vraiment étrange. Est-ce que je ne retourne pas un pointeur? ...

#include <stdio.h> 

int valid(int); 
int length(int); 
int to_digits(int); 
int to_num(int *, int); 
void sort_digits(int *, int); 
int max_substraction(int *, int); 

int i,j; 

int main() 
{ 
    int num; 
    scanf("%d", &num); 
    if(!valid(num)) 
    { 
     printf("Invalid!\n"); 
    } 
    else { 

     printf("%d", max_substraction(to_digits(num), length(num))); 
    } 
    return 0; 
} 

int length(int num){ 

    int cpy_of_num = num, len = 0; 
    do { 
     cpy_of_num /= 10; 
     len++; 
    } while(cpy_of_num != 0); 

    return len; 
} 

int valid(int num){ 
    int len = length(num); 
    if(len<2 || len>9){ 
     return 0; 
    } 
    return 1; 
} 
int to_digits(int num){ 
    int len = length(num), cpy_of_num = num; 
    int digits[len]; 
    for(i=len-1; i>=0; i--){ 
     digits[i] = cpy_of_num % 10; 
     cpy_of_num /= 10; 
    } 
    return *digits; 
} 
int to_num(int *digits, int len){ 
    int new_num = 0, mult = 1; 
    for(i=len-1; i>=0; i--){ 
     new_num += digits[i]*mult; 
     mult *= 10; 
    } 
    return new_num; 
} 
void sort_digits(int *digits, int len){ 
    for(i=1;i<len;i++){ 
     for(j=0;j<len-1;j++){ 
      if(digits[j] > digits[j+1]){ 
       int temp = digits[j]; 
       digits[j] = digits[j+1]; 
       digits[j+1] = temp; 
      } 
     } 
    } 
} 
int max_substraction(int *digits, int len){ 
    sort_digits(digits, len); 
    int max_num_digits[10], min_num_digits[10]; 
    for(i=0; i<len; i++){ 
     min_num_digits[i] = digits[i]; 
     max_num_digits[i] = digits[len-i-1]; 
    } 
    int min_num = to_num(min_num_digits, len); 
    int max_num = to_num(max_num_digits, len); 

    return max_num - min_num; 
} 

Answer 1

Le problème est dans l'appel de fonction

max_substraction(to_digits(num), length(num)) 

selon la signature,

int max_substraction(int *digits, int len) 

le premier devrait être un param int *, mais to_digits() vous renvoie un int !!

Ensuite, une déclaration de retour comme

return *digits; 

vous renvoie une valeur int, pas un pointeur. Cela dit, même si vous avez essayé, dans sa forme actuelle, le tableau digits ne peut pas être retourné par to_digits(), car il est local à la fonction. Vous devez disposer d'un stockage statique si vous souhaitez renvoyer le tableau . Maintenant, puisque par définition, les VLA ne peuvent pas avoir de stockage statique, vous pouvez utiliser des fonctions d'allocation de mémoire, comme malloc() et la famille.

Answer 2

Votre fonction to_digits a un type de retour déclaré comme int, alors qu'il essaye en fait de retourner un int *. Dans sa forme actuelle, le tableau cessera d'exister lorsque la fonction se terminera. Une allocation différente de la mémoire est donc nécessaire pour utiliser le tableau en dehors de la fonction to_digits.