Discussion :

[TIM.cpp]

Bonjour. SVP, y a-t-il un pro pour nous apprendre à déclarer:
1- Un pointeur sur un tableau d'entiers.
2- Un pointeur sur un tableau de pointeurs sur entiers.
3- Un pointeur sur un tableau de pointeurs constants sur entiers non constants.
4- Un pointeur sur un tableau de pointeurs non constants sur entiers constants.
5- Un pointeur sur un tableau de pointeurs constants sur entiers constants.
6- Un pointeur sur un tableau constant de pointeurs sur entiers.
7- Un pointeur sur un tableau constant de pointeurs constants sur entiers non constants.
8- Un pointeur sur un tableau constant de pointeurs non constants sur entiers constants.
9- Un pointeur sur un tableau constant de pointeurs constants sur entiers constants.
10- Un pointeur constant sur un tableau de pointeurs sur entiers.
11- Un pointeur constant sur un tableau de pointeurs constants sur entiers non constants.
12- Un pointeur constant sur un tableau de pointeurs non constants sur entiers constants.
13- Un pointeur constant sur un tableau de pointeurs constants sur entiers constants.
14- Un pointeur constant sur un tableau constant de pointeurs sur entiers.
15- Un pointeur constant sur un tableau constant de pointeurs constants sur entiers non constants.
16- Un pointeur constant sur un tableau constant de pointeurs non constants sur entiers constants.
17- Un pointeur constant sur un tableau constant de pointeurs constants sur entiers constants.

Merci d'avance.

[koala01]

Salut, et bienvenue sur le forum.

On va faire un deal : je te donnerai une réponse à au moins les trois quarts des cas, n'ayant pas tout lu, lorsque tu m'auras donné une réponse convaincante à une seule question: pourquoi voudrais tu faire tout cela en C++

[Bousk]

Les questions de ton exercice sont intéressantes mais nous ne faisons pas les devoirs.

[TIM.cpp]

Mais pourquoi tout le monde croit que c'est un devoir de la fac ? Je ne suis pas étudiant mais freelance. J'ai trop peiné à trouver des tutos assez précis sur les pointeurs. Savoir écrire ces déclarations m'aidera à mieux cerner le concept.

[jo_link_noir]

Absolument pas ! La syntaxe n'a strictement rien à voir avec le concept.

[dalfab]

Bonjour,

C'est juste un problème syntaxique. En comprendre un est suffisant pour comprendre tous les autres. C'est pourquoi je t'en ai déjà donné un sur un autre forum.
Je réitère ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* (const* const ptr)[N];

C'est trivial de trouver à quelle ligne il correspond (laquelle selon toi?) et à partir de ça, ça n'est que la syntaxe pour écrire tous les autres.
J'en parle dans mon cours dès la 1^ère demi-journée (il faut bien parler de pointeurs à un moment), et attention pour être freelance en C++ compte avant plusieurs années d'expériences concrètes.

[koala01]

Il faut bien comprendre qu'il n'y a -- en définitive -- qu'un seul cas dans lequel on commencera à travailler avec des pointeurs : lorsque l'on doit créer dynamiquement des données polymorphes. Autrement dit, quand on doit choisir à l'exécution le type d'une donnée parmi une hiérarchie de classes.

Et encore, à ce moment là, on veillera à utiliser les pointeurs intelligents! par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
class Base{
public:
    /* pour respecter la sémantique d'entité */
    Base(Base const &) = delete;
    Base & operator = (Base const &) = delete;
    /* pour pouvoir détruire les instances des classes dérivées quand on ne les connait que
     * comme étant du type de base
     */
    virtual ~Base();
    /* un exemple de fonciton connue */
    /* virtual */ void foo();
    /* ... */
};
class D1 : public Base{
    /* ... */
};
/* ... */ 
class DN : public Base{
    /* ... */
};
int main(){
    /* je veux connaitre toues les objets qui héritent de base */
    std::vector<std::unique_ptr<Base>> tab;
    /* je vais rajouter des instances de D1 ... DN, mais je perd l'information de leur type réel */
    tab.push_back(std::move(std::make_unique<D1>());
    tab.push_back(std::move(std::make_unique</* ... */>());
    tab.push_back(std::move(std::make_unique<DN>());
    /* Je  parcoure les objets que j'ai créés,  mais je ne les connais que comme étant du type Base */
    for(auto /* const */ & it : tab){
        /* je peux utiliser les fonctions déclarées dans Base uniquement */
        it.get()->foo()
    }
}

En dehors de ce cas, l'utilisation de pointeurs c'est bullshit !!!

Je t'ai fourni un code sur un autre forum que tu peux compiler à ton aise chez toi, dont l'exécution balaie toutes les objections que tu pourrais avoir vis à vis des classes de la STL. Fais le tourner, tu verra par toi-meme.

Et, si tu veux pas y passer ton temps, je le met même sur coliru, bien que j'aie du diviser le nombre d'élément par 1000: tu le verra ==>ICI<==

Dis toi bien que si je te propose le deal de t'indiquer la plupart de ces syntaxe si tu arrives à me donner une réponse convaincante, ce n'est pas pour t'embêter, mais pour te faire comprendre que je suis assez sur de moi que pour n'avoir que peu de chance d'avoir à te les expliquer. Car, finalement, cela revient à faire un pari, alors que, par principe, je ne parie pas si je ne suis pas sur de gagner

Si tu veux comprendre le concept des pointeurs, qu'il te suffise de savoir qu'un pointeur n'est jamais qu'une valeur numérique entière (généralement non signée) qui représente l'adresse mémoire à laquelle on espère (on est sensé) trouver une donnée du type indiqué, et que pour le reste, on crée des variables représentant cette valeur afin de les manipuler exactement comme n'importe quelle autre variables (mais, a priori, toujours par valeur).

[Jamatronic]

Comment quelqu'un qui ne connait pas les bases peut-il affirmer être développeur freelance ?

[Bousk]

Mais pourquoi tout le monde croit que c'est un devoir de la fac ?

Parce qu'en dehors d'un devoir légèrement sadique ces questions et leurs réponses ont un intérêt plus que nul.

[Invité]

Bonsoir,

Juste au passage, c'est la seconde fois que je le vois passer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    tab.push_back(std::move(std::make_unique<D1>());
    tab.push_back(std::move(std::make_unique</* ... */>());
    tab.push_back(std::move(std::make_unique<DN>());

Les expressions std::make_unique<. . .>(. . .) sont déjà des rvalues. Ces std::move sont complètement inutiles. (Et ici les parenthèses ne sont même pas équilibrées.)

[TIM.cpp]

Merci beaucoup, tout le monde ! je suis freelance en développement web. Et je me bât pour mieux comprendre mon language préféré: le C++. Je l'utilise déjà, pour certaine tâche de bas niveau. Et je souhaite devenir pro.

[koala01]

Merci beaucoup, tout le monde ! je suis freelance en développement web. Et je me bât pour mieux comprendre mon language préféré: le C++. Je l'utilise déjà, pour certaine tâche de bas niveau. Et je souhaite devenir pro.

Hé bien, si tu veux devenir pro en C++, commence par agir comme un pro du C++, et non comme un développeur C qui essaye d'adapter se connaissance à un "nouveau" langage, dont on lui a dit qu'il était "suffisamment pareil" que pour qu'il garde les mêmes habitudes!

Il faut bien comprendre que la relation qui lie le C++ au C est exactement la même que celle qui lie le français au latin : C++ dérive du C, tout comme le français dérive du latin. Et, pourtant, on ne t'a pas obligé à apprendre le latin avant de t'apprendre à parler en français. Pourquoi, selon toi Hé bien, tout simplement parce qu'il y a un monde de différence entre les deux langues.

Bien sur, tu pourras retrouver -- plus ou moins facilement -- la racine latine de certains mots français, et, soyons honnêtes, tu pourras sans doute éviter bien des fautes d'orthographe si tu y arrives, mais penses, par exemple, au déclinaisons du latin (tu sais: rosa, rosa, rosam et tous les autres) et compare les à "une rose" ou "des roses" (voire "la rose" et "les roses").

Hé bien, il en va de même entre le C++ et le C : bien sur, la notion de pointeurs existe en C++. Mais C++ diffère du C par le simple fait qu'il s'agit d'un langage à exceptions. En ce sens, et bien que cela m'arrache la gueule de l'admettre, C++ est beaucoup plus proche (hormis en ce qui concerne la philosophie) de langages comme le Java ou le C#.

De plus, on dispose de tellement de possibilités pour éviter d'avoir recours au pointeurs que les pros en arrivent à n'utiliser les pointeurs que contraints et forcés, lorsqu'il est vraiment clair qu'aucune autre solution n'est applicable. Et c'est tant mieux! Parce que les pointeurs n'étant jamais qu'une donnée qui contient l'adresse à laquelle on espère |devrait trouver une donnée du type indiqué :

1. il faut systématiquement s'assurer que l'adresse représentée ** semble ** être valide (différente de nullptr)
2. même lorsque l'adresse représentée ** semble ** valide, on n'a aucune certitude que nous y trouverons effectivement une donnée du type indiqué
3. de nombreux pointeurs étant utilisés pour récupérer l'adresse d'un espace mémoire alloué dynamiquement, si on "perd" le pointeur, on observe une fuite mémoire
4. si l'on essaye de libérer l'espace mémoire commençant à l'adresse indiquée par un pointeur alors que cet espace mémoire a déjà été libéré, on court à la catastrophe
5. j'en passe, et sans doute de meilleures

Alors, il est vrai qu'il y a des situations dans lesquelles on n'a pas d'autre choix que d'utiliser les pointeurs. Mais, contrairement au C pour lequel la compréhension des pointeurs arrive parmi les première chose qu'il faut acquérir, la compréhension de ce concept -- et de tout ce qui va avec -- peut|devrait être postposée jusqu'au moment où l'on n'aura sans doute pas d'autre choix que de les utiliser : lorsque l'on commencera à jouer avec les classes polymorphes.

Mais le délais obtenu devrait -- a priori -- te permettre d'avoir gagné "suffisamment d'expérience" que pour éviter les principaux écueils. Surtout si tu as pris l'habitude de te reposer sur la bibliothèque standard, et que l'utilisation des pointeurs intelligents -- vu qu'ils existent dans la bibliothèque standard depuis 2011 (dans des bibliothèques externes depuis bien plus longtemps) -- te parait donc *** relativement *** naturelle.

[TIM.cpp]

Merci infiniment.