Comment passer un tableau de taille spécifique en argument?

Question

J'ai une fonction qui génère une entrée sûre avec gestion des erreurs, donc il est plus propre à entrer des nombres (int). Mais je veux que l'un des arguments soit un tableau facultatif de longueur 2 qui contient les limites de l'entrée de la variable voulue.

Voici ce que j'ai pour l'instant:

//function prototype 
void input_number(int* variable, string text = "Input : ", int boundaries[2] = NULL); 

//function call 
int variable; 
input_number(&variable, "Choose a number between 0 and 10 : ", {0, 10}); 

Cela ne fonctionne pas, jeter l'erreur cannot convert '<brace-enclosed initializer list>' to 'int*' for argument '3' to 'void input_number(int*, std::__cxx11::string, int*)'

Comment puis-je passer un tableau de longueur 2 à la fonction?

De même, int[] = NULL est-il correct pour une valeur de tableau par défaut ou ai-je totalement tort?

Answer 1

Le message d'erreur explique le problème - un tableau est converti en un pointeur (au premier élément) lorsqu'il est passé comme argument à une fonction.

Une solution consisterait à passer un type struct qui a deux membres, et donner une valeur par défaut. Un exemple serait, puisque std::array est en fait une structure basé sur un modèle

void input_number(int* variable, std::string text = "Input : ", const std::array<int, 2> &bounds = {}); 

int variable; 
input_number(&variable, "Choose a number between 0 and 10 : ", {0, 10}); 

Cependant, toute structure de données qui permet de stocker deux valeurs, et être construit à l'aide d'un initializer_list<int>. Il existe d'autres exemples de ces types dans la bibliothèque standard - std::array n'est pas le seul.

Personnellement, j'omettre aussi le premier argument, et ont comme valeur de retour

int input_number(std::string text = "Input : ", const std::array<int, 2> &bounds = {}); 

// to call 

int variable = input_number("Choose a number between 0 and 10 : ", {0, 10}); 

Cela a le problème de la fonction de ne pas être en mesure de signaler une erreur (autre que en lançant une exception), mais votre approche aussi.

Personnellement, je ne voudrais pas non plus passer les limites comme arguments par défaut. Je le ferais simplement avec une surcharge de fonction;

int input_number(std::string input, int lower_bound, int upper_bound) 
{ 
    // do whatever you want 
} 

int input_number(std::string input) 
{ 
     return input_number(input, std::numeric_limits<int>::min(), std::numeric_limits<int>::max()); 
} 

qui oblige l'appelant à fournir soit aucun argument après le premier (dans ce cas, les limites par défaut sont utilisées) ou deux (qui spécifient les bornes) - faire passer un seul argument supplémentaire serait une erreur diagnostiquée. La seule différence par rapport à ce que vous avez demandé est que cela ne nécessite pas (implicitement ou explicitement) de construire un tableau ou une autre structure de données pour appeler la fonction - ce qui est sans doute plus facile à gérer pour l'appelant.

Answer 2

Essayez ceci:

void input_number(int* variable, string text = "Input : ", std::array<int, 2> boundaries = {});