Comment le standard C++ devrait-il être utilisé?

Question

J'ai cette question classique de savoir comment le C++ Standard (je veux dire le document officiel actuel des finalisés), par exemple. C++ 98, C++ 03 être utilisé pour apprendre et enseigner C++. Mon idée est seulement du point de vue d'un utilisateur C++ moyen et non pas du point de vue des juristes ou de quelqu'un qui souhaite faire partie du comité des normes, des compilateurs et ainsi de suite.

Voici mes personnelles pensées:

a) Il est le lieu de commencer à apprendre aweful C++. Des livres comme "C++ in a Nutshell", "Le langage de programmation C++" etc. font un très bon travail sur ce front tout en s'alignant étroitement sur la norme.

b) Il faut revenir à la norme que lorsque

• un compilateur donne un comportement qui ne correspond pas à ce que les livres communs disent ou,

• un certain comportement est incohérent dans compilateurs GCC, VS, Comeau etc. Je comprends le fait que ces compilateurs pourraient être incompatibles dans très peu de cas/coins sombres de la langue, par ex. Cependant, on en vient vraiment à connaître les différents comportements possibles du compilateur uniquement lorsque l'un d'entre eux est en cours de portage et/ou de migration vers un environnement différent ou lorsqu'il y a une mise à jour du compilateur, par exemple.

• si un concept est mal expliqué/pas expliqué dans les livres à portée de main par exemple. si c'est un concept vraiment avancé

Des idées, des idées, des recommandations à ce sujet?

Answer 1

La norme de langage C++ serait un endroit absolument terrible pour commencer à apprendre la langue. C'est dense, obtus et très long. Souvent, l'information que vous recherchez est répartie sur sept clauses différentes ou cachée dans la moitié d'une phrase dans une clause complètement indépendante de l'endroit où vous pensez qu'elle devrait être (ou pire, a behavior is specified in the sentence you ignored because you didn't think it was relevant).

Il a bien sûr ses usages. Pour ne citer que quelques-uns,

• Si vous pensez que vous avez trouvé un bogue dans un compilateur, il est souvent nécessaire de se référer à la norme pour vous assurer que vous n'êtes pas tout ce que le comportement comprenez mal spécifié est. Si vous trouvez un comportement incohérent entre les compilateurs, il est utile de rechercher ce qui est correct (ou ce qui est le plus correct), bien que vous ayez souvent besoin d'écrire des solutions de contournement. Si vous voulez savoir pourquoi les choses sont comme elles sont, c'est souvent une bonne référence: vous pouvez voir comment les différentes caractéristiques de la langue sont liées et comprendre comment elles interagissent. Les choses ne sont pas toujours claires, bien sûr, mais elles le sont souvent.Il y a beaucoup d'exemples condensés et de notes démontrant et expliquant le texte normatif.

• Si vous référencez le standard C++ dans un article sur Stack Overflow, vous obtenez plus a lot more upvotes. :-)

• Il est très intéressant d'apprendre la langue. C'est une chose d'écrire du code et de trébucher en obtenant des choses à compiler et à exécuter. C'est une autre chose d'essayer d'essayer de comprendre la langue dans son ensemble et de comprendre pourquoi vous devez faire les choses d'une certaine façon.

Answer 2

La norme devrait être utilisée pour assurer la portabilité du code. Lorsque vous écrivez du code C++ basique, vous n'avez pas besoin de vous référer aux standards, mais lorsque vous utilisez des templates ou une utilisation avancée de la STL, la référence à la norme est essentielle pour maintenir la compatibilité avec plusieurs compilateurs. futures versions.

Answer 3

J'utilise g++ pour compiler mes programmes C++ et là j'utiliser l'option -std=c++0x (plus tôt, -std=c++98) pour vous assurer que mon code est toujours conforme à la norme. Si je reçois un avertissement ou une erreur concernant la conformité aux normes, je fais des recherches pour m'éduquer et corriger mon code.

Answer 4

CPP coding guidelines 
MEMORY MANAGEMENT 

BUFFER OVERRUNS 

STATIC BUFFER OVERRUNS 

A static buffer overrun occurs when a buffer, which has been declared on the stack, is written to with more data than it was allocated to hold. The less apparent versions of this error occur when unverified user input data is copied directly to a static variable, causing potential stack corruption. 

HEAP OVERRUNS 

Heap overruns, like static buffer overruns, can lead to memory and stack corruption. Because heap overruns occur in heap memory rather than on the stack, some people consider them to be less able to cause serious problems; nevertheless, heap overruns require real programming care and are just as able to allow system risks as static buffer overruns. 
Soulflower - Oil and Handmade Organic Soap 
Perfect Remedy For All Skin & Hair Problems. Buy Now! 

ARRAY INDEXING ERRORS 

Array indexing errors also are a source of memory overruns. Careful bounds checking and index management will help prevent this type of memory overrun. 
1. Use memcpy_s instead of memcpy 
2. In memcpy_s destination size should be more than or equal to source size 
3. If destination size is less than source size, relevant handling to be implemented. e.g. 
a. creating fatal error log and throwing exception 
b. copying truncated data 

MEMORY LEAKS 

It is the responsibility of each application to “free” dynamically requested memory when it is finished using it. When an application dynamically allocates memory, and does not free that memory when it is finished using it, that program has a memory leak. 
1. Differentiate between delete of object and delete [] of array of objects. 
Incorrect 
char* myCharArray = new char[BUFF_SIZE]; 
delete myCharArray; 
Correct 
char* myCharArray = new char[BUFF_SIZE]; 
delete [] myCharArray; 
2. While deleting check for NULL. If not NULL, delete and set to NULL 
Correct 
If(ptrData!= NULL) 
{ 
delete ptrData; 
ptrData=NULL; 
} 

3. Check size of STL container before iterating over its elements. 

4. If STL containers contain pointers. Iterate over elements and delete each pointer individually. And clear container after this. 
Incorrect 

std::list<StructImageList*> listFinalImageIds //allocation and appending of pointers to list. ……… 

m_listFinalImageIds.clear(); 

Correct 

std::list<StructImageList*> listFinalImageIds //allocation and appending of pointers to list. …… //clean up after list use is completed. 

if(!m_listFinalImageIds.empty()) 

{ for(std::list<StructImageList*>::iterator it = m_listFinalImageIds.begin(); it != m_listFinalImageIds.end(); it++){ StructImageList* pData = *(it); 

if(pData!= NULL) { 

delete pData; pData = NULL; 

} 

} 

m_listFinalImageIds.clear(); 
5. Use of BSTR. use smart pointer _bstr_t for handling of BSTRs. 

https://msdn.microsoft.com/en-us/library/zthfhkd6.aspx 


more at : 

http://www.writeulearn.com/cpp-coding-guidelines/