Ancien programmeur a besoin de secrets STL

Question

Lorsque j'ai appris le C++, ils m'ont prévenu de ne pas utiliser le STL. C'était nouveau, bogué et inefficace. Récemment, je me suis trouvé en train de créer un conteneur pour un nouveau projet, et j'ai réalisé qu'il s'agissait probablement d'un cas de NIH et je devrais essayer le STL <vector>.

Malheureusement, cela ne fonctionne pas.

#include <stdio.h> 
#include <stdlib.h> 

#include <vector> 

class test { 
    public: 
    int x; 
}; 

int main(int argc,char *argv[]) { 
    std::vector<test> obj; 
    test *tmp=new test(); 
    tmp->x=42; 
    obj.push_back(tmp); 
    } 

g ++ me avertit qu'il n'y a pas de fonction concordante pour push_back, et que push_back prend const value_type & en tant que paramètre. J'ai essayé plusieurs castes pour forcer cela, mais il refuse de bouger.

J'ai maintenant perdu plus de temps à essayer de le faire de la «bonne» façon que ce qu'il aurait fallu pour écrire encore un autre conteneur et le déboguer.

Si cela ressemble à de la rage et de la frustration, vous êtes perspicace. J'ai déjà trouvé plusieurs questions comme la mienne, mais les réponses s'avèrent extraordinairement difficiles à suivre. Si c'était un site où les flammes voleraient, je m'attendrais à être grillé pour cela. Je me suis caché autour de stackoverflow pendant quelques années, et je parie qu'il y a quelqu'un qui pourrait "l'expliquer comme si j'avais cinq ans."

Y a-t-il une incantation à une seule couche pour forcer la distribution à fonctionner? Sinon, comment ces vecteurs sont-ils censés être utilisés?

Answer 1

perdre le pointeur

std::vector<test> obj; 
test tmp; 
tmp.x=42; 
obj.push_back(tmp); 

Vous avez un vecteur de test ne test* donc je ne sais pas pourquoi vous avez essayé d'impliquer des pointeurs. L'un des avantages majeurs de la STL est qu'elle vous permet d'éviter les pointeurs, qui en tant que C++ expérimenté, je suis sûr que vous savez sont une cause majeure de bugs.

Answer 2

Effectuez l'une de ces 2 choses

std::vector<test*> obj; 
test *tmp=new test; 
tmp->x=42; 
obj.push_back(tmp); 

Ou

std::vector<test> obj; 
test tmp; 
tmp.x=42; 
obj.push_back(tmp); 

Si vous déclarez un vector de test objets, push_back alors un objet test. Si vous déclarez des pointeurs vector de test, puis appuyez sur test *.

Answer 3

En plus de perdre le pointeur comme @John (à juste titre, à mon avis) a suggéré, je ferais ajouter un cteur à votre test classe:

class test { 
    int x; 
public: 
    test(int x) : x(x) {} 
}; 

Cela peut être utilisé pour une conversion implicite , de sorte que vous pouvez aussi sauter la variable tmp, laissant quelque chose comme:

std::vector<test> t; 

t.push_back(42); 

... et le compilateur utiliser le cteur pour convertir automatiquement le 42 à unObjetavec sa valeur x définie sur 42.

Si vous voulez protéger contre une conversion accidentelle d'un int aléatoire en un test, vous pouvez choisir un point à mi-chemin.Faire le explicit de cteur, et convertir explicitement dans l'appel à push_back:

class test { 
    int x; 
public: 
    explicit test(int x) : x(x) {} 
}; 

// ... 

std::vector<test> t; 

t.push_back(test(42)); 

Oh, je devrais probablement mentionner un autre détail: en supposant que vous utilisez un (assez) nouveau compilateur, vous pouvez utiliser à la place emplace_back de push_back. Si on lui donne une chance, il créera le nouvel objet en place au lieu de le copier dans le vecteur. Cela ne fera aucune différence pour une minuscule classe comme votre test (contenant seulement un seul int), mais pour quelque chose de grand qui coûte cher à copier, la différence peut être significative.

Answer 4

Vous ne devez pas stocker de pointeurs C++ dans des collections std. Vous stockez les objets eux-mêmes comme John le suggère. Une foule de bogues mémoire très délicate résulte de l'utilisation de pointeurs bruts.
Peut-être que votre professeur l'avait fait s'il croyait que le STL était bogué. C'est vraiment robuste. La STL peut sembler inefficace si vous stockez de gros objets dans des collections car ceux-ci seront copiés, ce qui est coûteux en temps et en mémoire. D'où la croyance à l'inefficacité qui est également fausse. L'astuce consiste à utiliser smart pointers. Ceux-ci rendent l'allocation de tas beaucoup plus facile et fonctionnent brillamment avec le STL. C'est alors efficace et pas du tout buggé. C'est beaucoup mieux que ce qui est raisonnable de s'inscrire.