Traiter avec des tampons de char

Si une fonction vous donne une méthode de savoir combien de caractères il retournera, utilisez-le. Votre exemple GetCurrentDirectory est un bon exemple:

std::vector<TCHAR> buffer(length, 0);
// assert(buffer.capacity() >= length);  // should always be true
GetCurrentDirectory(length, &buffer[0]);

Je suppose que votre intérêt vient principalement d'une perspective de performance, car des solutions telles que le vecteur, la chaîne, le wstring, etc. fonctionneront généralement même pour interagir avec C API. Je recommande d'apprendre à utiliser ceux-ci et comment les utiliser efficacement. Si vous en avez vraiment besoin, vous pouvez même écrire votre propre allocateur de mémoire pour les rendre super rapides. Si vous êtes sûr qu'ils ne sont sûrs qu'ils ne sont pas ce dont vous avez besoin, il n'y a toujours aucune excuse pour que vous n'écrivez pas à ne pas écrire une simple enveloppe pour gérer ces tampons de cordes avec Raii pour les cas dynamiques.

avec ça hors de la route:

passe le tampon comme et tampon [0] Meilleur style de programmation que de passer amortir? (Je préfère et tampon [0].)

non. Je considérerais que ce style sera légèrement moins utile (certes être subjectif ici) car vous ne pouvez pas l'utiliser pour passer un tampon NULL et qu'il faudrait donc faire des exceptions à votre style pour passer des pointeurs à des tableaux qui peuvent être nuls. Il est requis si vous passez dans des données de STD :: Vecteur vers une API C S'attendant à un pointeur, cependant.

Y a-t-il une taille maximale qui est considéré comme sûr pour la pile alloué tampons?

Cela dépend de vos paramètres de plate-forme et de votre compilateur. Règle simple: Si vous doutez de savoir si votre code déborde de la pile, écrivez-le d'une manière qui ne peut pas.

est un tampon statique (charcuterie statique tampon [n];) plus rapide? Y a-t-il autres arguments pour ou contre cela?

Oui, il y a un grand argument contre celui-ci, et c'est que cela rend votre fonction ne ré-entrant plus. Si votre application devient multipliée, ces fonctions ne seront pas en sécurité. Même dans une application à une seule-filetée, partager le même tampon lorsque ces fonctions sont appelées de manière récursive peut entraîner des problèmes.

Qu'en est-il de l'utilisation du tampon de char * statique = nouveau char [n]; et ne jamais supprimer le tampon? (Réutiliser le même tampon chacun appel.)

Nous avons toujours les mêmes problèmes avec la réintensif.

Je comprends cette allocation de tas devrait être utilisé quand (1) traitant de grands tampons ou (2) tampon maximum la taille est inconnue au moment de la compilation. Sommes Il y a d'autres facteurs qui jouent dans La décision de la pile / de l'allocation de tas?

La pile déroulant détruit les objets sur la pile. Ceci est particulièrement important pour la sécurité des exceptions. Ainsi, même si vous allouez la mémoire sur le tas dans une fonction, elle devrait généralement être gérée par un objet sur la pile (ex: pointeur intelligent). //// @ Voir Raii.

Si vous préférez le sprintf_s, memcpy_s, ... Variantes? (Visual Studio a essayé de me convaincre de cela Pendant longtemps, mais je veux une seconde AVIS: P)

MS a eu raison à propos de ces fonctions étant des alternatives plus sûres, car elles n'ont pas de problèmes de dépassement de tampon, mais si vous écrivez ce code comme (sans écriture de variantes pour d'autres plates-formes), votre code sera marié à Microsoft puisque elle être non portable.

Lorsque vous utilisez des tampons statiques, vous pouvez utiliser Type de retour Const de caractères *. Est-ce (généralement) une bonne ou une mauvaise idée? (JE se rend compte que l'appelant aura besoin faire sa propre copie pour éviter que le appel suivant changerait le précédent Valeur de retour.)

Je dirais dans presque tous les cas, vous souhaitez utiliser Const Char * pour les types de retour pour une fonction renvoyant un pointeur sur un tampon de caractères. Pour une fonction de retourner un caractère mutable * est généralement déroutant et problématique. Soit il renvoie une adresse à des données globales / statiques qu'il ne devrait pas utiliser en premier lieu (voir Recettentrance ci-dessus), les données locales d'une classe (s'il s'agit d'une méthode) dans laquelle le renvoi de la capacité de la classe à Maintenir les invariants en permettant aux clients de l'altérer, mais ils aiment (ex: la chaîne stockée doivent toujours être valides) ou la mémoire de retour spécifiée par un pointeur transmise à la fonction (le seul cas où l'on pourrait raisonnablement affirmer que le charnel mutable * devrait être retourné).

1) tampon et & tampon [0] devrait être équivalent.

2) Les limites de la taille de la pile dépendront de votre plate-forme. Pour la plupart des fonctions simples, ma règle de base personnelle est quelque chose de plus de ~ 256kb est déclarée dynamiquement; Il n'y a pas de véritable rime ni raison de ce nombre, cependant, c'est juste ma propre convention et il est actuellement dans les tailles de pile par défaut pour toutes les plates-formes que je développe.

3) Les tampons statiques ne sont pas plus rapides ou plus lents (à toutes fins utiles). La seule différence est le mécanisme de contrôle d'accès. Le compilateur place généralement des données statiques dans une section distincte du fichier binaire que des données non statiques, mais il n'existe aucun avantage notable / performance significatif ou pénalité impliqué. Le seul moyen réel de dire certitude est d'écrire le programme à la fois et de les utiliser (car de nombreux aspects de vitesse impliqués ici dépendent de votre plate-forme / compilateur).

4) Ne renvoyez pas un pointeur const si l'appelant devra le modifier (qui défait le point de const ). Utilisez const pour les paramètres de fonction et les types de retour si et uniquement s'ils ne sont pas conçus pour être modifiés. Si l'appelant devra modifier la valeur, votre meilleur pari est que l'appelant passe la fonction un pointeur sur un tampon pré-alloué (ainsi que la taille du tampon) et pour la fonction d'écrire les données dans ce tampon.

5) La réutilisation d'un tampon peut entraîner une amélioration des performances des plus gros tampons dues à contourner la surcharge impliquée dans l'appelant Malloc / ou neuf < / code> / Supprimer à chaque fois. Cependant, vous risquez d'utiliser des données anciennes si vous oubliez d'effacer le tampon à chaque fois ou que vous essayez d'exécuter deux copies de la fonction en parallèle. Encore une fois, la seule façon réelle de savoir, bien sûr, c'est d'essayer les deux manières et de mesurer la durée pendant laquelle le code prend pour courir.

6) Un autre facteur d'allocation de pile / de tas est de la scoraison. Une variable de pile dépasse de la portée lorsque la fonction qu'il vit en retour, mais une variable allouée de manière dynamique sur le tas peut être renvoyée à l'appelant en toute sécurité ou accédée à la prochaine fois que la fonction est appelée (A strtok ).

7) Je recommanderais à l'utilisation de sprintf_s , memcpy_s et amis. Ils ne font pas partie de la bibliothèque standard et ne sont pas portables. Plus vous utilisez ces fonctions, plus vous aurez de travail supplémentaire lorsque vous souhaitez exécuter votre code sur une autre plate-forme ou utiliser un compilateur différent.