Pseudocode-code complete Chapter 9th

Previously, I thought that the role of pseudo code is only to make the logic of the program clearer, and I can only show it to myself. Today I saw the code complete with a very deep experience. The first is that pseudocode is not only used for writing code, but can be directly used as a program comment. Let's look at an example to see how to write a good pseudocode and use it.

Increment resource number by 1

Allocate a DLG struct using malloc

If malloc () returns NULL then return 1

Invoke osrsrc_init to initialize a resource for the operating system

* Hrsrcptr = Resource number

Return 0

This is a very bad pseudo-code. First, the logic is unclear, and the written program is hard to understand. As a pseudo-code, it contains the code details of the C language * hrsrcptr. And return 0, which can be fully encapsulated. The modified code is as follows:

Keep track of current number of resources in use

If another resource is available

Allocate a dialog box structure

If a dialog box structure cocould be allocated

Note that one more resource is in use

Initialize the resource

Store the resource number at the location provided by the caller

Endif

Endif

Return true if a new resource was created; else return false

We can see that the language implemented using this code can be implemented not only in C, but also in other languages, developers can easily see this pseudo code. The reason is that it is encapsulated with a higher level, implemented in natural language, and the logic is clearer.

Why is pseudocode used? It can be seen that the implementation and modification of pseudo code is very easy, which is equivalent to programming at the language level without the need to design language details. The modification cost in terms of language details is very large, but it is easy to modify at the pseudo-code level.

How can I modify the pseudo code directly as a comment? Let's look at another example:

How to use these pseudocodes?

 

1. /* This routine outputs an error message based on an error code
3. Supplied by the calling routine. The way it outputs the message
5. Depends on the current processing state, which it retrieves
7. On its own. It returns a value indicating success or failure.
9. */
13. Status reporterrormessage (
15. Errorcode errortoreport
17. ){
19. // Set the default status to "fail"
21. Status errormessagestatus = status_failure;
25. // Look up the message based on the error code
27. Message errormessage = lookuperrormessage (errortoreport );
31. // If the error code is valid
33. If (errormessage. validcode ()){
35. // Determine the processing method
37. Processingmethod errorprocessingmethod = currentprocessingmethod ();
41. // If doing interactive processing, display the error message
43. // Interactively and declare success
45. If (errorprocessingmethod = processingmethod_interactive ){
47. Displayinteractivemessage (errormessage. Text ());
49. Errormessagestatus = STATUS_SUCCESS;
51. }
53. // If doing command line processing, log the error message to
55. // Command line and declare success
57. Else if (errorprocessingmethod = processingmethod_commandline ){
59. CommandLine messagelog;
61. If (messagelog. Status () = commandlinestatus_ OK ){
63. Messagelog. addtomessagequeue (errormessage. Text ());
65. Messagelog. flushmessagequeue ();
67. Errormessagestatus = STATUS_SUCCESS;
69. }
71. Else {
73. // Can't do anything because the routine is already Error Processing
75. }
77. Else {
79. // Can't do anything because the routine is already Error Processing
81. }
83. }
85. // If the error code isn' t valid, policy the user that
87. // Internal error has been detected
89. Else {
91. Displayinteractivemessage (
93. "Internal error: Invalid error code in reporterrormessage ()"
95. );
97. }
101. // Return status information
103. Return errormessagestatus;
105. }

Directly comments the pseudo code and add the language code in the blank space. This process makes good use of pseudocode and can also make the programming idea clearer. In essence, splitting the process is also the idea of splitting. First glance

I was shocked by the code complete section. The direct use of pseudocode.

To sum up, write pseudocode first, as a help to clarify the ideas and find errors, and then directly write the pseudo code as a comment in the comments. In this example, C ++ code is used.