Standards for Programming Practice - Revision history

Dvernon at 08:46, 20 January 2020

2020-01-20T08:46:15Z

Dvernon: /* Writing Robust Programs */

2017-07-12T06:22:18Z

‎Writing Robust Programs

Dvernon at 08:28, 17 February 2015

2015-02-17T08:28:33Z

Dvernon at 08:26, 17 February 2015

2015-02-17T08:26:59Z

Dvernon: Dvernon moved page Recommended Standards for Programming Practice to Standards for Programming Practice

2015-02-15T12:24:31Z

Dvernon moved page Recommended Standards for Programming Practice to Standards for Programming Practice

Dvernon at 05:53, 30 August 2014

2014-08-30T05:53:21Z

Dvernon: /* Writing Robust Programs */

2014-08-30T05:51:52Z

‎Writing Robust Programs

Dvernon at 05:50, 30 August 2014

2014-08-30T05:50:05Z

Dvernon at 05:41, 30 August 2014

2014-08-30T05:41:27Z

Dvernon at 12:00, 29 August 2014

2014-08-29T12:00:15Z

@@ Line 32: / Line 32: @@
 In the above, you should replace <code>FILENAME</code> with the root of the name of the include file being guarded e.g. if the include file is cognition.h you would write the following:
  #ifndef COGNITION_H
   #define COGNITION_H
    ...  header file contents go here
@@ Line 115: / Line 115: @@
   function_name: error message

@@ Line 57: / Line 57: @@
 ===Writing Robust Programs===
-Avoid arbitrary limits on the size or length of any data structure, including arrays, by allocating all data structures dynamically. Use malloc or new to create data-structures of the appropriate size. Remember to avoid memory leakage by always using free and delete to deallocate dynamically- created data-structures.
+Avoid arbitrary limits on the size or length of any data structure, including arrays, by allocating all data structures dynamically. Use <code>malloc</code> or <code>new</code> to create data-structures of the appropriate size. Remember to avoid ''memory leakage'' by always using <code>free</code> and <code>delete</code> to deallocate dynamically-created data-structures.
-Check every call to malloc or new to see if it returned <code>NULL</code>.
+Check every call to <code>malloc</code> or <code>new</code> to see if it returned <code>NULL</code>.
 You must expect <code>free</code> to alter the contents of the block that was freed. Never access a data structure after it has been freed.

@@ Line 116: / Line 116: @@
   function_name: error message
-===Copyright Messages===
-−
-If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
-−
-  <Program name and version>
- Copyright (C) 2014 DREAM Consortium
- FP7 Project 611391 co-funded by the European Commission
- Author:  <name of author>, <author institute>
- Email:   <preferred email address>
- Website: www.dream20202.eu
- This program comes with ABSOLUTELY NO WARRANTY.
-−
 ----
 Return to [[The CINDY Cognitive Architecture]] main page.

← Older revision		Revision as of 08:26, 17 February 2015
Line 127:		Line 127:
	Website: www.dream20202.eu		Website: www.dream20202.eu
	This program comes with ABSOLUTELY NO WARRANTY.		This program comes with ABSOLUTELY NO WARRANTY.
		+
		+
		+	----
		+	Return to [[The CINDY Cognitive Architecture]] main page.

← Older revision		Revision as of 05:53, 30 August 2014
Line 1:		Line 1:
−	~~<strong>WORK IN PROGRESS ... DON'T READ</STRONG>~~
	==C++ Language Conventions Access to Data Members==		==C++ Language Conventions Access to Data Members==
	Don’t make any class data member public without good reason.		Don’t make any class data member public without good reason.

← Older revision	Revision as of 12:24, 15 February 2015
(No difference)

@@ Line 13: / Line 13: @@
   void example_function (int an_integer, long a_long, short a_short,
-                          float a_float, double a_double)
+                       float a_float, double a_double)
   ...
@@ Line 25: / Line 25: @@
 Include files should protect against multiple inclusion through the use of macros that guard the file. Specifically, every include file should begin with the following:
-Conditional Compilation
+ #ifndef FILENAME_H
 Avoid the use of conditional compilation. If your code deals with different configuration options, use a conventional if-else construct. If the code associated with either clause is long, put it in a separate function. For example, please write:
-   if (HAS_FOO) {
-      ...
+ if (HAS_FOO) {
+    ...
 else {
-... }
+ else {
 instead of:
-   #ifdef HAS_FOO
-      ...
+ #ifdef HAS_FOO
-#else ...
+    ...
-#endif
+ #else
-Writing Robust Programs
+    ...
 Avoid arbitrary limits on the size or length of any data structure, including arrays, by allocating all data structures dynamically. Use malloc or new to create data-structures of the appropriate size. Remember to avoid memory leakage by always using free and delete to deallocate dynamically- created data-structures.
 Check every call to malloc or new to see if it returned NULL.
 You must expect free to alter the contents of the block that was freed. Never access a data structure
-after it has been freed.
+Check every call to malloc or new to see if it returned <code>NULL</code>.
 If malloc fails in a non-interactive program, make that a fatal error. In an interactive program, it is better to abort the current command and return to the command reader loop.
-When static storage is to be written during program execution, use explicit C or C++ code to ini- tialize it. Reserve C initialize declarations for data that will not be changed. Consider the following two examples.
-   static int two = 2; // two will never alter its value
+You must expect <code>free</code> to alter the contents of the block that was freed. Never access a data structure after it has been freed.
-   ...
-   static int flag;
-   flag = TRUE;        // might also be FALSE
+If <code>malloc</code> fails in a non-interactive program, make that a fatal error. In an interactive program, it is better to abort the current command and return to the command reader loop.
 Constants
 Numerical constants (literals) should not be coded directly, except for -1, 0, and 1, which can appear in a for loop as counter values.
 Variable Assignments
 Avoid assigning several variables to the same value in a single statement. It is hard to read.
 Do not use the assignment operator in a place where it can be easily confused with the equality operator.
-if (c++ = d++) { // AVOID!
+ if (c++ = d++) { // AVOID!
-      ...
+    ...
-−
+ }
 should be written as
 Do not use embedded assignments in an attempt to improve run-time performance. This is the job of the compiler.
-   d = (a = b + c) + r; // AVOID!
 should be written as
-   a = b + c;
-   d = a + r;
+ a = b + c;
-Parentheses
+ d = a + r;
-Use parentheses liberally in expressions involving mixed operators to avoid operator precedence prob- lems. Even if the operator precedence seems clear to you, it might not be to others — you shouldn’t assume that other programmers know precedence as well as you do.
-if (a == b && c == d)     // AVOID!
+===Parentheses===
 if ((a == b) && (c == d)) // USE
-Standards for Graphical Interfaces
+Use parentheses liberally in expressions involving mixed operators to avoid operator precedence problems. Even if the operator precedence seems clear to you, it might not be to others — you shouldn’t assume that other programmers know precedence as well as you do.
-When you write a program that provides a graphical user interface (GUI), you should use a cross- platform library. At the very least, it must possible to compile your GUI code for both a Window environment and a Linux environment. The FLTK GUI library [23] satisfies this requirement.
-Error Messages
+ if (a == b && c == d)     // AVOID!
 Error messages should look like this:
-Copyright Messages
+ function_name: error message
 If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
 <Program name and version>
-Copyright (C) 2014 DREAM Consortium
+ <Program name and version>
-FP7 Project 611391 co-funded by the European Commission
+ Copyright (C) 2014 DREAM Consortium
-Author:  <name of author>, <author institute>
+ FP7 Project 611391 co-funded by the European Commission
-Email:   <preferred email address>
+ Author:  <name of author>, <author institute>
-Website: www.dream20202.eu
+ Email:   <preferred email address>
-This program comes with ABSOLUTELY NO WARRANTY.
+ Website: www.dream20202.eu

@@ Line 3: / Line 3: @@
 Don’t make any class data member public without good reason.
 One example of appropriate public data member is the case where the class is essentially a data structure, with no behaviour. In other words, if you would have used a struct instead of a class, then it’s appropriate to make the class’s data members public.
-E.2 C Language Conventions
 Use the Standard C syntax for function definitions:
-   void example_function (int an_integer, long a_long, short a_short)
-   ...
+ void example_function (int an_integer, long a_long, short a_short)
-If the arguments don’t fit on one line, split the line according to the rules in Section ??:
+ ...
 void example_function (int an_integer, long a_long, short a_short,
                            float a_float, double a_double)
-...
+ ...
 Declarations of external functions and functions to appear later in the source file should all go in one place near the beginning of the file (somewhere before the first function definition in the file), or else it should go in a header file.
-Do not put extern declarations inside functions. E.3 General Issues
-Use of Guards for Header Files
+Do not put extern declarations inside functions.
 Include files should protect against multiple inclusion through the use of macros that guard the file. Specifically, every include file should begin with the following:
     #ifndef FILENAME_H

@@ Line 1: / Line 1: @@
+<strong>WORK IN PROGRESS ... DON'T READ</STRONG>
-E.1 C++ Language Conventions Access to Data Members
+==C++ Language Conventions Access to Data Members==
 Don’t make any class data member public without good reason.
 One example of appropriate public data member is the case where the class is essentially a data structure, with no behaviour. In other words, if you would have used a struct instead of a class, then it’s appropriate to make the class’s data members public.