Ce qui suit est bien sûr tout n'est pas assez précis. Prendre avec un grain de sel quand vous le lire :)
Ainsi, les trois choses que vous consultez sont automatiques, statique et dynamique de la durée de stockage, qui a quelque chose à voir avec combien de temps les objets de vivre et quand ils commencent leur vie. Vous utilisez automatique de la durée de stockage de courte durée et de petites données, ce qui est nécessaire seulement localement dans certains bloc:
if(some condition) {
int a[3]; // array a has automatic storage duration
fill_it(a);
print_it(a);
}
La durée de vie se termine dès que nous quittez le bloc, et ça commence dès que l'objet est défini. Ils sont les plus simples de la durée de stockage, et sont plus rapides que dans la dynamique particulière de stockage durée.
Vous utilisez statique de la durée de stockage de variables libres, qui peut être accessible par un code tout temps, si leur champ d'application permet une telle utilisation (espace de noms de champ), et pour les variables locales qui ont besoin d'allonger leur durée de vie à travers la sortie de leur portée (portée locale), et pour les variables membres, qui doivent être partagées par tous les objets de la classe (classs champ d'application). Leur durée de vie dépend de la portée, ils sont. Ils peuvent avoir de l' espace de noms de la portée et de l' étendue locale et de la portée de classe. Ce qui est vrai à propos de deux d'entre eux, une fois que leur vie commence, la durée de vie se termine à la fin du programme. En voici deux exemples:
// static storage duration. in global namespace scope
string globalA;
int main() {
foo();
foo();
}
void foo() {
// static storage duration. in local scope
static string localA;
localA += "ab"
cout << localA;
}
Le programme imprime abababcar localA n'est pas détruit lors de la sortie de son bloc. Vous pouvez dire que les objets qui ont une portée locale commencer à vie lorsque le contrôle atteint leur définition. Pour localA, ce qui se passe lorsque la fonction du corps est entré. Pour les objets dans l'espace de noms de la portée, la durée de vie commence au démarrage du programme. Le même est vrai pour les objets statiques de la classe de la portée:
class A {
static string classScopeA;
};
string A::classScopeA;
A a, b; &a.classScopeA == &b.classScopeA == &A::classScopeA;
Comme vous le voyez, classScopeA n'est pas lié à des objets particuliers de sa classe, mais à la classe elle-même. L'adresse de tous les trois noms ci-dessus est le même, et tous les désigner le même objet. Il y a des règles spéciales concernant quand et comment les objets statiques sont initialisés, mais n'oublions pas d'inquiétude à ce sujet maintenant. Qu'entend-on par le terme statique de l'ordre d'initialisation fiasco.
La dernière durée de stockage est dynamique. Vous l'utilisez si vous voulez avoir des objets de vivre sur une autre île, et vous voulez mettre des pointeurs autour de cette référence. Vous avez également de les utiliser si vos objets sont gros, et si vous voulez créer des tableaux de taille connu au runtime. En raison de cette flexibilité, des objets ayant une dynamique de durée de stockage sont longue et complexe à gérer. Les objets de cette dynamique durée commencer à vie, lorsque approprié nouvel opérateur invocation qui se passe:
int main() {
// the object that s points to has dynamic storage
// duration
string *s = new string;
// pass a pointer pointing to the object around.
// the object itself isn't touched
foo(s);
delete s;
}
void foo(string *s) {
cout << s->size();
}
Sa durée de vie ne se termine que lorsque vous appelez supprimer pour eux. Si vous oubliez que, ces objets n'ont pas de fin de vie. Et les objets de la classe que de définir un utilisateur déclaré constructeur de ne pas avoir leurs destructeurs appelé. Des objets ayant une dynamique de durée de stockage nécessite la manutention manuelle de leur durée de vie et la mémoire associée à cette ressource. Les bibliothèques existent pour faciliter leur utilisation. Explicite de collecte des ordures pour des objets particuliers peuvent être établis à l'aide d'un pointeur intelligent:
int main() {
shared_ptr<string> s(new string);
foo(s);
}
void foo(shared_ptr<string> s) {
cout << s->size();
}
Vous n'avez pas de soins sur l'appel de supprimer: La partagé ptr-t-il pour vous, si le dernier pointeur qui fait référence à l'objet est hors de portée. L'partagé ptr a lui-même automatique de la durée de stockage. Donc sa durée de vie est géré automatiquement, permettant de vérifier s'il doit supprimer l'a souligné objet dynamique dans son destructeur. Pour shared_ptr de référence, voir le boost de documents: http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm
