Comment appelé une procédure dont un tableau initialiser sans taille lui à été passer en paramètre ?

Version imprimable

11/09/2017, 18h26
cauchyy

1 pièce(s) jointe(s)

Comment appelé une procédure dont un tableau initialiser sans taille lui à été passer en paramètre ?

Pièce jointe 310919
Bonjour a tous !!!
J'ai déclarer un tableau de string que j'appelle "nom[ ]" sans préciser sa taille (en mettant le vide dans ses crochets) , puis je l'ai initialiser !!

Maintenant j'ai récupérer sa taille à l'aide de sizeof(nom)/sizeof(string) !! et ça marche parfaitement .

Maintenant l’orque je veux appeler ma procédure "tri_tableau" , je passe mon tableau "nom" en paramétre !! et lorsque je compile ça affiche un message d'erreur !!

Comment appelé une procédure dont un tableau initialiser sans taille lui à été passer en paramètre ??? c'est ça ma principale question.

Merci d'avance les programmeurs !!
11/09/2017, 18h57
bacelar

Arrêtez avec ces tableaux à la C, on est en C++.
Utilisez un std::vector.
11/09/2017, 19h45
foetus
Il y a plusieurs problèmes avec ton code :
- Il faut lire la documentation, mais lorsque tu crées un tableau statique, il me semble que les éléments ne peuvent pas être modifiés (dans ton cas ce sont des pointeurs). Donc tes chaînes de caractères ne peuvent pas être déplacées.
- Il faut passer ton tableau avec un double pointeur, sinon tu vas travailler sur une copie (passage par valeur/ recopie)
- Détail : Même si un tableau est différent d'un pointeur, il faut mieux passer un paramètre pointeur qu'un paramètre [] Parce que 1) on ne travaille plus (sauf rare cas) avec un tableau C, mais avec un std::vector 2) ton tableau va être dégradé en pointeur
- Détail : Ton calcul sizeof pour calculer la taille ne fonctionne pas tout le temps, si je ne dis pas de bêtises
- Détail : using namespace std; <- même si c'est dans un fichier .cpp, il faut soit rien/ std::string soit using std::string; (<- un truc comme cela)
- Détail : Ta procédure fait 2 choses un tri et des swap. En théorie, il faudrait sortir le swap, on le faire faire à son tableau

Une solution raisonnablement propre serait:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
//la référence non constante permet de modifier l'argument passé en parametre
void tri(std::vector<std::string> & chaines) {
    // std::string fourni un opérateur de comparaison ( string < string)
    // std::sort (dans <algorithm>) permet le tri de n'importe quelle séquence selon un ordre arbitraire, ou l'opérateur < si on ne précise rien.
    // je ne vais donc pas le coder moi-même.
    std::sort(chaines.begin(), chaines.end());
}
 
int main() {
    std::vector<std::string> noms = {"lala", "lololo", "pipipi"};
    const auto nombre = noms.size(); // vector fournit size(), directement
 
    tri(noms); // comme noms est passé en référence modifiante (non constante), il est effectivement trié.
 
    // j'ajoute toujours une ligne de préfixe avant d'afficher une liste, pour savoir ce qui est affiché
    std::cout << "Les " << nombres << " noms sont:" << std::endl;
    for (auto const& nom : noms) {
        std::cout << nom << std::endl;
    }
    return 0;
}

Et encore, idéalement, je ne ferai même pas la fonction tri, ou j'en ferai une template:

Code:

1
2
template <typename C>
inline void sort_collection(C & values) { sort(values.begin(), values.end()); }

Ce point-ci est pour ta future culture. Tu peux zapper complètement, ou demander des explications.

12/09/2017, 10h39
ternel
Citation:
Envoyé par foetus

Il y a plusieurs problèmes avec ton code :

Il faut lire la documentation, mais lorsque tu crées un tableau statique, il me semble que les éléments ne peuvent pas être modifiés (dans ton cas ce sont des pointeurs). Donc tes chaînes de caractères ne peuvent pas être déplacées.
Il faut passer ton tableau avec un double pointeur, sinon tu vas travailler sur une copie (passage par valeur/ recopie)
Détail : Même si un tableau est différent d'un pointeur, il faut mieux passer un paramètre pointeur qu'un paramètre [] Parce que 1) on ne travaille plus (sauf rare cas) avec un tableau C, mais avec un std::vector 2) ton tableau va être dégradé en pointeur
Détail : Ton calcul sizeof pour calculer la taille ne fonctionne pas tout le temps, si je ne dis pas de bêtises
Détail : using namespace std; <- même si c'est dans un fichier .cpp, il faut soit rien/ std::string soit using std::string; (<- un truc comme cela)
Détail : Ta procédure fait 2 choses un tri et des swap. En théorie, il faudrait sortir le swap, on le faire faire à son tableau
Point 1:
Le problème n'est pas avec les tableaux statiques, mais avec les chaines de caractères statiques. Il se pose avec char*, car un literal de chaine de caractère tel que "lala" n'est pas modifiable, même si son adresse peut-être mise dans un char* (et encore, ca dépend).
Il ne se pose pas pour des std::string.

Tenter de modifier un litéral de chaine est un comportement indéfini. Le compilateur est autorisé de les stocker dans une zone en lecture seule, ou de combiner plusieurs chaines partageant un même suffixe (comme "la" et "lala").
En C, un tel litéral est du type char[], en C++03, c'était possible même si c'est un char const[].
C'est impossible sans effort explicite en C++11.

Point 2: Je conseille vivement de préférer une réference plutot qu'un pointeur.
De toute façon, un double pointeur n'est pas requis car ce qui est passé est l'adresse du premier élément, copier cette adresse est sans impact.
Le double pointeur n'est potentiellement nécessaire que si on souhaite réallouer le tableau, et personnellement, je préfèrerai une référence sur un simple pointeur.

Point 4:"Détail : Ton calcul sizeof pour calculer la taille ne fonctionne pas tout le temps, si je ne dis pas de bêtises:"
Cela fonctionne si le tableau vraiment un tableau, pas un paramêtre (parce qu'un tableau en paramètre de fonction est remplacé par un pointeur).

Point 5:
"Détail : using namespace std; <- même si c'est dans un fichier .cpp, il faut soit rien/ std::string soit using std::string; (<- un truc comme cela)"
Explication concrète:
les namespace servent à éviter les collisions de noms entre des choses distinctes (comme std::vector, une collection et vector d'une bibliothèque de mathématique, par exemple).
L'instruction using namespace injecte les noms dans l'espace englobant l'instruction using et le namespace utilisé. En général, c'est l'espace global, ce qui annule l'effet du namespace.
- soit tu préfixes
- soit tu utilises un using chose;. Un tel using a l'avantage de pouvoir être utilisé dans un bloc ou une fonction (et donc de ne pas polluer le reste du code).
En général, la recommandation est de ne jamais utiliser de using depuis l'espace std (ni l'espace entier, ni un sous-ensemble).
Comme tout "jamais" a des exceptions, ici, c'est sauf si l'effet est très limité (dans un petit bloc) ou améliore énormément la lisibilité.
19/09/2017, 22h24
Astraya

Bonjour,

Tu dois passer un pointeur car comme dis plus haut, le passage en paramètre d'un tableau statique C est converti en pointeur sur le premier element.

Tu ne dois pas utiliser std::vector mais std::array dans ton cas : http://fr.cppreference.com/w/cpp/container/array