C language traps and defects

For this reason, the method of copying the previous N elements in the array x to the array y in the following:

i = 0; While (i

The problem is Y [i]'s address does not guarantee the value before I grow. In some implementations, this is possible; but in other implementations are not possible. Another situation will fail with the same reason:

i = 0; While (i

The following code is workable:

i = 0; While (i

Of course, this can be abbreviated as:

For (i = 0; i

4.2 &&, || and! Operators

There are two logical operators in C, in some cases, can be exchanged: bit operators &, | and ~, and logical operators &&, || A programmer replaces the corresponding class of operators with a class operator to get some strange effect: The program may work correctly, but this is purely casual.

&& ,|| These operators return 1 indicating "true" and returning 0 means "false", and && and || operators can determine their return values ​​through the number of operands on the left, no value to the right number of operands.

Therefore, 10 is zero because 10 is non-zero; 10 && 12 is 1, because 10 and 12 are not zero; 10 || 12 is also 1, because 10 is non-zero. Further, 12 of the last expression will not be evaluated, and f () in 10 || F () will not be evaluated.

Consider the following sections used to find a specific element in a table:

i = 0; While (i

The meant behind this cycle is that if i is equal to TABSIZE, the elements are not found. Otherwise, i contains an index of an element.

Suppose this example && accident is replaced for &, this loop may still work, but only two lucky situations can stop.

First, both operations return 0 when the condition is false, and when the condition is true, returns 1. As long as x and y are 1 or 0, X & Y and X && Y have the same value. However, if the non-zero value other than 1 means "true", this two operators will not work.

Second, since the array element does not change, it is harmless when the last element of the array enters a position, and the loop will be lucky. The wrong program will cross the end of the array, because & unlike &&, always evaluate all operands. Therefore, the last acquisition of the loop is equal to TABSIZE. If tabsize is the number of elements in tab, it will be taken to a value that does not exist in Tab. 4.3 The subscript starts from scratch

In many languages, the number of the array of N elements is the number of its element and its subscript, from 1 to N strict. But not this in C.

An element having no subscript N-N-element in a C array having n elements, the subscript of the element from 0 to N - 1. Therefore, programmers who go to C language from other languages ​​should be particularly carefully used:

INT I, A [10]; for (i = 1; i <= 10; i ) a [i] = 0;

The purpose of this example is to set each element in A to 0, but there is no desired effect. Because the comparison I <10 in the FOR statement is replaced by an element that is numbered 10 in the I <= 10, the element does not exist is set to 0, so that the word behind the memory is destroyed. If the compiler compiles the program assigns memory to the user variable according to the descending address, then a later is i. Setting I zero will cause the loop to fall into an infinite loop.

4.4 C does not always convert the argument

The following blocks will fail because two reasons are:

Double S; s = SQRT (2); Printf ("% g / n", s);

The first reason is that SQRT () requires a Double value as its parameters, but not yet. The second reason is that it returns a Double value but does not have this claim. Corrected methods only one:

Double S, SQRT (); s = SQRT (2.0); Printf ("% g / n", s);

Two simple rules in C controlling the conversion of the function parameters: (1) The integer is converted to int; (2) is converted to Double than the short floating point type than the Double. All other values ​​are not converted. Make sure the functional parameter type is correctly exercising the programmer's responsibility.

Therefore, a programmer must be passed to the Float or Double type parameter only if you want to use a function such as SQRT () to accept a Double type parameter. Constant 2 is an int, so its type is wrong.

When a function of a function is used in an expression, its value is automatically converted to an appropriate type. However, in order to complete this automatic conversion, the compiler must know the type of the function actually returned. Functions without a further denomination are assumed to return int, so the function that is called such a function is not necessary. However, SQRT () returns Double, so you must have a name before successfully use it.

In fact, C implementation usually allows a file to include the number of SQRT () to the library functions, but for the programmers who write functions to write, it is also necessary - or saying extraordinary The people of the C procedure are necessary.

Here is a more spectacular example:

Main () {Int i; char C; for (i = 0; i <5; i ) {scanf ("% d", & c); Printf ("% d", i);} printf ("/ n" }

On the surface, this program reads five integers from standard inputs and writes 0 1 2 3 4 to standard output. In fact, it doesn't always do this. For example, in some compilers, its output is 0 0 0 0 1 2 3 4.

why? Because C is the name of CHAR instead of INT. When you let Scanf () read an integer, it needs a pointer to an integer. But here it gets a pointer of a character. But scanf () does not know that it doesn't get it needs: it will be viewed as a pointer to integer and stores an integer to there. Since integer occupies more memory, this will affect the memory near C. It is exactly what is the compiler in the vicinity; in this case this is likely to be the low position of I. Therefore, whenever a value is read into C, I is set to zero. When the program finally reaches the end of the file, scanf () no longer attempts to put a new value to c, i can grow normally until the end of the loop.

4.5 Pointer is not an array

The C program typically converts a string to a character array ending with an empty character. Suppose we have two such strings S and T, and we want to connect them as a separate string R. We usually be done using library functions strcpy () and strcat (). The following obvious method does not work:

Char * r; strcpy (r, s); strcat (r, t);

This is because R is not initialized to point to anywhere. Although r may potentially represent a piece of memory, this does not exist until you assign it.

Let's try again, and allocate some memory for R:

Char R [100]; STRCPY (R, S); STRCAT (R, T);

This is only able to work when the string pointed to by S and T is not very large. Unfortunately, C requiring us that the size specified for the array is a constant, so it cannot be determined if R is large enough. However, many C implementation with a library function called Malloc (), which accepts a number and allocates so much memory. There is usually a function to become strlen (), can tell us how many characters in a string: So we can write:

Char * r, * malloc (); r = malloc (Strlen (S) Strlen (T)); strcpy (r, s); strcat (r, t);

However, this example will fail because of two reasons. First, malloc () may deplete the memory, and this event is only represented by quietly returning an empty pointer.

Second, more importantly, malloc () does not assign enough memory. A string is ended with an empty character. The strlen () function returns the number of characters contained in its string parameters, but does not include empty characters ending. Therefore, if strlen (s) is n, then s needs n 1 characters to hold it. So we need to allocate an additional character for R. Coupled with checking Malloc () is successful, we get:

Char * r, * malloc (); r = malloc (Strlen (S) Strlen (T) 1); if (! r) {Complain (); exit (1);} STRCPY (R, S); STRCAT (r, t);

4.6 Avoiding a message

Bikecdoche, Sin-Eck-duh-key is a literary technique, a bit similar to the metaphor or metaphor, explained in the Oxford English Dictionary as follows: "A more comprehensive term is buy itd for a less comprehensive or vice vcers; AS WHOL for Part For Whole, Genus for Species or Species for Genus, ETC. (will be used as uncommon units, or vice versa;, as a whole, the whole, generally, generally to special or special ,and many more.)"

This can accurately describe errors that typically make pointers in Ceration as their pointing data. It will often happen in a string. For example: char * p, * q; p = "xyz";

Although it is considered to be XYZ sometimes useful, this is not true, it is very important to understand this. The value of P is a pointer to the 0th element in an array of four characters, which is 'x', 'Y', 'Z' and '/ 0'. So if we do now:

Q = P;

P and Q will point to the same block. The characters in the memory are not copied by assigning values. This situation looks like this:

To remember, copy a pointer does not copy what it points to.

So if we will perform:

Q [1] = 'y';

q The memory pointed to contains a string xyz. P is also because P and Q point to the same memory.

4.7 Empty pointer is not empty string

The result of converting an integer into a pointer is implementation-dependent, except for one exception. This exception is constant 0, which guarantees a pointer that is converted into a pointer that is not equal to other effective pointers. This value is usually defined like this:

#define null 0

But its effect is the same. An important thing to remember is that when it is used as a pointer, it will never be released. In other words, after you assign 0 to a pointer variable, you cannot access the memory it points to. Can't write this:

IF (p == (char *) 0) ...

You can't write this:

IF (strcmp (p, (char *) 0) == 0) ...

Because strCMP () is always viewed by its parameters.

If P is an empty pointer, it is also invalid to write:

Printf (p);

or

Printf ("% s", p);

4.8 integer overflow

The C language is very clear about the overflow or underflow of integer operation.

As long as one operand is unsigned, the result is no symbol, and is molded with 2n, where n is the word length. If the number of operands are symbol, the result is undefined.

For example, suppose A and B are two non-negative integer variables, you want to test whether A B overflow. A obvious way is this:

IF (A B <0) Complain ();

Usually, this is not working.

Once A B has spill, it is meaningless to any beta of the result. For example, on some machines, an additional operation sets an internal register to four states: positive, negative, zero or overflow. On such a machine, the compiler has the right to implement the above example to first add A and B, and then check if the internal register status is negative. If the operation overflows, the internal register will be in an overflow state, which will fail.

A correct way to successfully succeed is to detrimentally, it is necessary to convert between symbolic arithmeters:

IF ((int) (unsigned) b) <0) COMPLAIN ();

4.9 shift operator

Two reasons will make people feel annoying using shift operators:

In the right shift calculation, the space is filling with 0 padding or using symbolic bits? What are the number of shifts?

The answer to the first question is simple, but sometimes it is related. If the operand to be shifted is unsigned, it will be moved into 0. If the operand is a symbol, the implementation has the right to decide whether to move into 0 or move into the symbol bit. If you care about the space in a right shift, use unsigned to declare the variable. This way you have the right to assume that the vacancy is set to 0. The answer to the second question is equally simple: if the length of the length to be shifted is N, the number of shifts must be greater than or equal to 0 and is strictly less than n. Therefore, it is impossible to remove all bits from the variable in a separate operation.

For example, if an int is 32 bits, and N is an int, write n << 31 and n << 0 is legal, but n << 32 and n << -1 are illegal.

Note that even if the symbol is moved into the vacancy, the right shift operation of a symbolic integer and the power of 2, is not equivalent. To prove this, it is impossible to consider (-1) >> 1, this is not 0. [Translation: (- 1) / 2 results are 0. ]

5 library function

Each useful C program uses library functions, because there is no way to build input and output into the language. In this section, we will see some non-expected behaviors that are widely used in some cases in some situations.

5.1 Getc () Returns an integer

Consider the following procedure:

#include

MAIN () {

Char C;

While ((c = getchar ())! = EOF)

PUTCHAR (C);

}

This program seems to have to say that standard input is copied to standard output. In fact, it doesn't matter all all.

The reason is that C is declared as a character rather than an integer. This means that it will not receive all characters that may appear include EOF.

So there are two possibilities here. Sometimes some legal input characters can cause the same value of C to carry and EOF, and sometimes C will not store the EOF value. In the previous case, the program will stop replication in the middle of the file. In the latter case, the program will fall into an infinite loop.

In fact, there is still a third possibility: the program will accidentally work correctly. C language reference manual strictly defines the expression

((c = getchar ())! = EOF)

the result of. Its 6.1 declaration:

When a longer integer is converted to a shorter integer or a char, it will be cut on the left; the exceeding bit is simply discarded.

Section 7.14 declaration:

There are a lot of assignment operators, they are all combined from right to left. They all require a left value as an operand on the left, and the type of assignment expression is the type of operand on the left. Its value is the value of the left operating number of values.

The combined effect of these two clauses is that the high level of getchar () must be discarded, and the truncated value is compared to EOF later. As part of this comparison, c must be expanded into an integer, or take the zip of the left side 0 to fill, or appropriately taking a symbol extension.

However, some compilers do not implement this expression correctly. They do to assign a lower number of getchar () values ​​to C. But in the comparison of C and EOF, they use the value of getchar ()! The compiler that makes this instance can be "correctly" work.

5.2 Buffer Output and Memory Allocation

When a program generates an output, how important it can be immediately seen? This depends on the program.

For example, the terminal is displayed on the terminal and requires people to answer one problem in front of the terminal, people can see the output to know what the input is critical. On the other hand, if it is output to a file, and eventually transmitted to a row printer, only all the output can eventually reach there.

The display immediately arranged is usually much more expensive than the output of it is temporarily stored in a large piece. Therefore, C realization usually allows the programmer control to generate how much output is actually written. This control is often defined as a library function called SetBuf (). If BUF is an array of characters with an appropriate size, then

SetBUF (stdout, buf);

The output that tells the I / O library to the stdout should be buffered as an output buffer as a buf, and wait until the BUF is full or the programmer calls FFLUSH (). Suitable size in the buffer

It is defined as bufsiz.

Therefore, the following program explains that the standard input is copied to the standard output by using setbuf ():

#include

MAIN () {

INT C;

Char buf [bufsiz];

SetBUF (stdout, buf);

While ((c = getchar ())! = EOF)

PUTCHAR (C);

}

Unfortunately, this program is wrong because a subtle reason.

To know where the problem is, we need to know when the last refresh is in the buffer. Answer; After the main program is completed, the cleaning of the cleaning is performed before the control is retracted to the operating system. At this moment, the buffer has been released!

There are two ways to avoid this problem.

First, use a static buffer or explicitly declare to static:

Static char buf [buffsiz];

Or move the entire statement to the main function.

Another possible way is to dynamically allocate buffers and never release it:

Char * malloc (); setbuf (stdout, malloc ());

Note In the latter case, you don't have to check the return value of malloc (), because if it fails, it will return an empty pointer. SetBUF () can accept an empty pointer as its second parameter, which will make STDOUT into non-buffered. This will run very slow, but it can run.

6 Preprocessor

The running program is not what we have written: Because the C preparation is converted first. For two main reasons (and many times), the preprocessor provides us with some simplified ways.

First, we hope to change all instances (such as the size of the table) [9] by changing a number and recoiling the program.

Second, we may want to define something, they look like a function but there is no function to call the required operation overhead. For example, Putchar () and getChar () are usually implemented as macros to avoid function calls to each character's input and output.

6.1 Macro is not a function

Some of the programmers sometimes treat them equivalent because the macros can appear like a function. Therefore, look at the definition below:

#define max (a, b) ((a)> (b)? (a): (b))

Pay attention to all brackets in the macro. They are in order to prevent A and B from being brought to a ratio> priority low.

An important issue is that the macro of MAX () is two times and will be evaluated twice. Therefore, in this example, if the A is large, A will be evaluated twice: once in comparison, and the other is when calculating the max () value.

This is not only inefficient, and there will be an error:

Biggest = x [0]; i = 1; While (i

When max () is a true function, this will work normally, but when max () is a macro, it will fail. For example, suppose X [0] is 2, x [1] is 3, x [2] is 1. Let's take a look at what happens during the first cycle. The assignment statement will be expanded to: biggest = ((Biggest)> (x [i ]): (x [i ]));

First, BiggeST is compared to X [i ]. Since i is 1 and x [1] is 3, this relationship is "false". Its side effects is that I increases to 2.

Since the relationship is "false", the value of X [i ] is to be assigned to Biggest. However, at this time I becomes 2, so the value assigned to the Biggest is the value of X [2], that is, 1.

Avoiding these issues is to ensure that the parameters of the max () macro have no side effects:

Biggest = x [0]; for (i = 1; i

There is also a dangerous example is a mixed macro and its side effects. This is from the eighth version of UNIX

The definition of the PUTC () macro:

#define PUTC (x, p) (- (p) -> _ CNT> = 0? (* (p) -> _ ptr = (x)): _flsbuf (x, p)))

The first parameter of the PUTC () is a character to be written to the file, and the second parameter is a pointer to an internal data structure representing a file. Note that the first parameter can be used to use something like * z , although it appears twice in the macro, it will only be evaluated once. The second parameter will be evaluated twice (in the macro body, X appear twice, but due to its two appearances in one: two sides, there is a case in the PUTC () There is only one evaluation value). Since the file parameters in the PUTC () may have side effects, this occasionally there will be problems. However, in the user manual documentation: "Since PUTC () is implemented as a macro, it may have side effects. In particular, PUTC (C, * F ) does not work correctly." But PUTC (* C , F) It is possible to work in this implementation.

Some C is very unhappy. For example, no one can handle PUTC (* C , F) correctly. Another example, consider the TouPper () function that appears in many C libraries. It converts a lowercase letter into a corresponding uppercase letter, while other characters are unchanged. If we assume that all lowercase letters and all uppercase letters are adjacent (might gap between case), we can get such a function:

TouPper (c) {if (c> = 'a' && c <= ') C =' A '-' A '; RETURN C;}

In many C implementations, in order to reduce the call overhead than actual calculations, it is usually achieved as a macro:

#define TouPper (C) ((c)> = 'a' && (c) <= 'z'? (c) ('A' - 'A'): (c))

Many times this is indeed a better than the function. However, when you try to write TouPper (* p ), we will appear strange results.

Another place to note is that the use of macros can produce huge expressions. For example, continue to consider the definition of MAX ():

#define max (a, b) ((a)> (b)? (a): (b))

Suppose we define this definition to find the maximum in A, B, C, and D. If we write directly:

Max (A, Max (B, Max (C, D)))))

It will be expanded to:

(((a)> ((((((((((((((((((((((c)> (d)? (c): ((((c): ((c): ((c): (((c)> (d)? d)))))))))))))))))))))))): (((((((((((((((((((((((((((((c)> (d) ? (c): (d))))))))))))))))))

This is surprisingly huge. We can make it shorter by balanced operands:

Max (Max (A, B), Max (C, D))

This will get:

(((((a)> (b))> ((c)> (d)? (c): (D))))? (((a)> (b) ? (a): (b))): ((c)> (d)? (c): (d))))))))))))))))))))))))

This looks still written:

Biggest = a; if (Biggest

It is better.

6.2 Macro is not type definition

A usual use of macros is to ensure that multiple things in different places have the same type:

#define footype struct foofootype a; footype b, c;

This allows programmers to change the types A, B, and C by only one line in the program, although A, B, and C may declare to different parts of the country.

Use such macro definitions and portable advantages - all C compilers support it. Many C compilers do not support another method:

Typedef struct foo footype;

This defines FOOTYPE as a new type equivalent to Struct Foo.

These two methods for type names can be equivalent, but TypeDef is more flexible. For example, consider the following example:

#define t1 struct foo * typedef struct foo * t2;

These two definitions make T1 and T2 equivalent to a pointer to Struct Foo. But see what happens when we try to declare more than one variable in a row:

T1 A, B; T2 C, D;

The first statement is expanded to:

Struct foo * a, b;

Here a a defined as a structural pointer, but B is defined as a structure (rather than a pointer). In contrast, both C and D are defined as a pointer to the structure, as T2 is like a true type.

7 portability defect

C is implemented and run on many machines. This is also the reason why the C procedure written in one place should be easily transferred to another programming environment.

However, because there are many implementations, they don't communicate with others. In addition, different systems have different needs, so the C implementation on a machine and how many on the other.

Since many early C implementations are related to UNIX operating systems, the nature of these functions is detailed in the system. When some people began to implement C in other systems, they try to make the behavior of the library similar to the behavior in the UNIX system.

But they are not always able to succeed. What's more, many people start from different versions of UNIX systems, and some of the nature of some library functions inevitably occur. Today, a C programmer must know many of these subtle differences if they want to write programs for users in different environments.

7.1 What are the names in a name?

Some C compilers treat all characters in an identifier as a signature. And other characters outside the storage identifier will ignore a limit. The target program generated by the C compiler will be handled by the loader to access subroutines in the library. The loader typically applies its own constraints for the names they can handle. A common loader constraint is that all external names must only be capitalized. In the face of such a loader constraint, the C realizes will force all external names to be capitalized. Such constraints are described in Section 2.1 of the C LAN Reference Manual.

A identifier is a character and a digital sequence, and the first character must be a letter. Underline _ calculates letters. Capital letters and lowercase letters are different. Only the top eight characters are signatures, but you can use more characters. There are more limitations that can be used by multiple assembler and loaders:

Here, some examples continue to give some examples if some implementations require the external identifier to have a separate case format, or less than eight characters, or both.

Because of all of this, it is important to choose the identifier carefully in a program that can be portable. Selecting Print_fields and Print_float for two subprograms. This is not a good way.

Consider this significant function:

Char * malloc (unsigned n) {char * p, * malloc (); p = malloc (n); if (p == null) PANIC ("Out of Memory"); Return P;}

This function is a simple way to ensure exhautive memory without causing no detection. Programmers can replace malloc () by calling mallo (). If malloc () misfortune fails, PANIC () will be called to display an appropriate error message and terminate the program.

However, what happens when the function is used in a system that ignores the case difference. At this time, the name Malloc and Malloc are equivalent. In other words, the library function malloc () is completely replaced by the Malloc () function above, and when Malloc () is called itself. Obviously, the result is that the first attempts to allocate memory will fall into a recursive loop and confusion. But in some implementations that can be distingurated, this function is still working.

7.2 How big is an integer?

C Provide three integers sizes for programmers: ordinary, short and long, and characters, their behavior is like a small integer. C language definition does not make any guarantee for the size of the various integers:

The four dimensions of the integer are non-decreasing. The size of ordinary integers should be sufficient to store any array subscript. The size of the character should reflect the essence of a particular hardware.

Many modern machines have 8 characters, but there are some 7-bit 9-bit characters. So characters are usually 7, 8 or 9 bits.

Long integer is usually at least 32 bits, so a long integer can be used to represent the size of the file.

Normal integers are usually at least 16 bits, because too small integers will limit the maximum size of an array.

A short integer is always 16 bits.

What does this mean in practice? The most important point is that don't expect any specific accuracy. Informal case you can assume a short integer or a normal integer is 16 bits, and a long integer is 32-bit, but it does not guarantee that there will always be these sizes. You can of course use ordinary integers to compress the size and subscript, but when a variable must store a tens of thousands of numbers?

A more portable approach is to define a "new" type:

Typedef long Tenmil;

Now you can use this type to declare a variable and know that it is width. In the worst case, you can change all of these variables as needed to change this individual type definition.

7.3 The character is a symbol or no symbol?

Many modern computers support 8 characters, so many modern C compilers implement the characters as an 8-bit integer. However, not all compilers explain these 8 digits in the same way.

These issues becomes particularly important when converting a CHAR system into a larger integer. For the opposite conversion, the result is a good definition: excess bit is simply dropped. But a compiler converts a char to an int but need to make a selection: Is Char considerate as a symbol or no sign? If the former, the CHAR is extended to int symbolic bits; if it is the latter, you should use 0 to populate 0. The results of this decision are very important for those who are used to high position 1 when handling characters. This determines that the 8-bit character range is from -128 to 127 or from 0 to 255. This also affects the design of the programmer to the hash table and the conversion table.

If you care about whether a character value is seen as a negative position, you should explicitly declare it as unsigned char. This ensures that it is a symbol in some implementations when converting to an integer, and is not as symbols in some implementations as a normal CHAR variable.

In addition, there is a misunderstanding that when C is a character variable, it can be written to a unsigned integer with the equivalent price of C. This is wrong because a char value is converted to INT before any operation (including conversion). At this time, C will first convert to a symbol integer to convert to an unsigned integer, which will produce strange results.

The correct method is to write (unsigned char) c.

7.4 Right shift is a symbol or no symbol?

Here again, repeat: How to care about how to move the right movement is best declared to the quantity of all to be shifted as unsigned.

7.5 How to round?

Suppose we use B to except A to get the merchant for q q number R:

q = a / b; r = a% B;

We temporarily assume B> 0.

What is the association between A, B, Q and R?

Most importantly, we expect Q * B R == a because this is the definition of the remainder. If the symbol of A changes, we expect Q's symbols to change, but the absolute value is unchanged. We want to guarantee R> = 0 and R

These three points clearly describe integer division and existence. Unfortunately, they can't be true at the same time.

Consider 3/2, more than 1 business. This satisfies the first point. What about -3 / 2? According to the second point, the commercial should be -1, but if this is the case, the remainder must be -1, which violates the third point. Alternatively, we can satisfy the third point by marking the remainder to 1, but at this time, it should be -2 according to the first point. This in violation of the second point.

Therefore, C and anywhere of any language that implements integer division rounds must abandon at least one of the above three principles.

Many programming languages ​​have given up the third point, requiring the remaining symbols must be the same. This ensures the first point and the second point. A lot of C is doing this.

However, the definition of the C language guarantees only the first point and | r | <| b | and when A> = 0 and B> 0 r> = 0. This is smaller than the second point or third point, in fact, some compilers satisfy the second or third point, but not common (if an implementation may always be rounded to the farthest direction) .

Although sometimes there is no need to flexibility, the C language is enough to allow us to do what we have to do, provide what we want to know. For example, suppose we have a number n to represent some of the functions of characters in an identifier, and we want to get a hash table inlet H, where 0 <= h <= HashSize. If we know that N is non-negative, we can write:

H = n% hashsize;

However, if n may be negative, this is not good, because h may be negative. However, we know H> -hashsize, so we can write: h = n% hashsize; if (n <0) h = hashsize;

Similarly, N declaration is available for unsigned.

7.6 How big is a random number?

This size is fuzzy and also affected by the design of the library. In the only C implementation running on the PDP-11 [10] machine, there is a function called RAND () to return a (pseudo) random non-negative integer. The integer length of the PDP-11 includes a symbol bit 16 bits, so the RAND () returns an integer between 0 and 215-1.

When C is implemented on VAX-11, the length of the integer becomes 32 positions. So what is the RAND () function on VAX-11?

For this system, the University of California believes that the return value of RAND () should cover all possible non-negative integers, so their RAND () version returns an integer between 0 and 231-1.

The people at AT & T feel that if the RAND () function returns a value between 0 and 215, it is easy to expect RAND () to return a program that is less than 215, ported to VAX-11 .

Therefore, it is difficult to write a program that does not depend on implementation and call the RAND () function.

7.7 case switching conversion

TouPper () and Toolower () functions have similar history. They were originally implemented as Hong:

#define TouPper (C) ((C) 'A' - 'A') # define TOLOWER (C) ((c) 'A' - 'A')

When a lowercase letter is given as an input, TouPper () will generate the corresponding uppercase letters. TOLOWER (). Both macros rely on the realized character set, which requires all the differences between uppercase letters and corresponding lowercase letters are constant. This assumption is valid for ASCII and EBCDIC character sets, possibly not very dangerous, because these unmatched macros can be encapsulated into a separate file and contain them.

These macros have a defect, namely: when a given thing is not an appropriate character, it will return garbage. Therefore, the following is unable to work by using these macros to convert a file to lowercase:

INT C; while ((c = getchar ())! = EOF) PUTCHAR (TOLOWER (C));

We must write:

INT C; While ((c = getchar ())! = EOF) PUTCHAR (Isupper (c)? TOLOWER (C): C);

In this regard, UNIX Development organization in AT & T reminds us that TouPper () and Tolower () are tested in advance by some appropriate parameters. Consider rewriting these macros:

#define TouPper (C) ((c)> = 'a' && (c) <= 'z'? (c) 'a' - 'a': (c)) # Define TOLOWER (C) ((C) )> = 'A' && (c) <= 'z'? (C) 'a' - 'a': (c))

However, we must know that the three appearances of C here must be evaluated, which will destroy expressions such as TouPper (* p ). Therefore, you can consider rewriting TouPper () and TOLOWER () as a function. TouPper () looks like this: int Toupper (INT C) {IF (C> = 'a' && c <= 'z') Return C 'A' - 'A'; Return C;}

TOLOWER () is similar.

This change brings more questions that will introduce the function call overhead each time you use these functions. Our hero thinks some people may not be willing to pay these overhead, so they will be named:

#define _toupper (c) ((c) 'a' - 'a') # define _tolower (c) ((c) 'a' - 'a')

This allows users to choose convenient or speed.

In fact, there is only one question: Berkeley's people and other C realizes did not follow this. This means that a program that uses TouPper () or TOLOWER () written on the AT & T system, and if not delivering the correct case letter parameter, you may not work in other C implementations.

If you don't know these history, it may be difficult to track such errors.

7.8 Release, reassign again

Many C implementation provides users with three memory allocation functions: malloc (), realloc (), and free (). Call Malloc (n) Returns a pointer to a newly allocated memory with n characters, which can be used by programmers. Passing a pointer to the memory allocated by malloc () can be reused by malloc (). By a pointer to the assigned area and a new size call realloc () can expand or narrow the new dimensions, which may be copied during this process.

Maybe someone will think, the truth is a bit slight. Below is a description of the Realloc () that appears in the System V interface definition:

Realloc changes a block of the SIZE byte by PTR and returns the pointer (possibly move) pointer. The content below one size in the new old size will not be changed.

This segment contains a copy of this paragraph in the reference manual of the Unix System. In addition, another paragraph describing Realloc ():

If the block pointed to by the PTR after the last call Malloc, Realloc or Calloc, Realloc can still work; therefore, the order of Free, Malloc, and Realloc can utilize Malloc compressed search strategies.

Therefore, the following code snippet is legal in the Unix seventh edition:

Free (p); p = realloc (p, newsize);

This feature retains in systems derived from Unix Seventh Edition: You can release a storage area before you reallocate it. This means that the content in the memory released in these systems can be guaranteed until the next memory allocation. Therefore, in these systems, we can use the following strange ideas to release all the elements in a linked list:

For (p = head; p! = null; p = p-> next) free (char *) P);

And don't worry that free () will cause P-> Next to be unavailable.

Needless to say, this technology is not recommended, because not all C implementation can keep its content long enough time after memory is released. However, the seventh edition of the manual has left an undeclared question: the original implementation of Realloc () is actually necessary to release the redistribution. For this reason, some C processes are released first, and there is a problem when they are transplanted into other implementations. 7.9 One example of a portability problem

Let us look at the problem that has been solved many times in many times. The following program comes with two parameters: a long integer and a function (pointer). It converts an integer transition bit decimal number and uses characters representing each of them to call a given function.

Void PrintNum (long n, void (* p)) {if (n <0) {(* p) ('-'); n = -n;} if (n> = 10) printnum (N / 10) , p); (* p) (N% 10 '0');

This program is very simple. First check if N is negative; if yes, a symbol is printed and n becomes a positive number. Next, the test is N> = 10. If yes, it contains two or more numbers in its decimal representation, so we recursively call printnum () to print all the numbers outside the last digit. Finally, we print the last digit.

This program - due to its simple - with many portability issues. The first is a method of converting N low digit into a character form. Using n% 10 to get the value of the low digit is good, but adding '0' to get the corresponding character, it is not good. This addition assumes that the number of characters corresponding to the number of orders in the machine, and therefore, the value of '0' 5 and '5' is the same, and so on. Although this assumption is established for the ASCII and EBCDIC character sets, it may not be found for other machines. Avoiding this method is to use a table:

Void PrintNum (long n, void (* p)) {if (n <0) {(* p) ('-'); n = -n;} if (n> = 10) printnum (N / 10) , p); (* p) ("0123456789" [n% 10]);

Another problem occurs when n <0. At this time, the program prints a negative number and sets N to -n. This assignment can overflow because the negative number of negative numbers that can be represented on the machine using 2 is more than the positive number. For example, one (long) integer has a k-bit and an additional bit representation symbol, then -2K can be represented and 2K is not.

There are many ways to solve this problem. The most intuitive one is to assign N to a UNSIGNED long value. However, some c will not implement unsigned long together, so let's take a look at the don't do it.

On the first implementation and the second implementation machine, change the symbol of a positive integer guarantee that there is no overflow. The problem is only when there is a symbol that changes a negative number. Therefore, we can avoid this problem by avoiding the N to become positive.

Of course, once we print a negative symbol, we can see the negative and positive numbers as the same. The following method is forced that N is negative after the print symbol, and all of our algorithms are completed with a negative value. If we do this, we must ensure that the part of the print symbol in the program is only executed once; a simple method is to divide this program into two functions:

Void PrintNum (LONG N, VOID (* P) ​​()) {IF (n <0) {(* P) ​​('-'); PrintNeg (N, P);} else printneg (-n, p);} Void PrintNeg (long N, Void (* P) ​​()) {if (n <= -10) PrintNeg (N / 10, P); (* P) ​​("0123456789" [- (n% 10)]); } printnum () Now only checks if the number to be printed is negative; if it is, print one symbol. Otherwise, it calls PrintNeg () with a negative value of N. We also changed the origin of Printneg () to accommodate n forever is negative or zero.

What are we get? We use N / 10 and N% 10 to get N leading numbers and end numbers (via appropriate symbol transformation). Calling an integer division behavior is achieved when one of the operands is negative. Therefore, n% 10 may be positive! At this time, - (n% 10) is a positive number, which will exceed the end of our numeric character array.

In order to solve this problem, we build two temporary variables to store merchants and remainder. After completing the method, we check if the remainder is within the correct range, if not, adjust these two variables. Printnum () has not changed, so we only list printneg ():

Void printneg (long n, void (* p) ()) {long {INT R; if (r> 0) {r - = 10; q ;} if (n <= -10) {printneg (q, p );} (* P) ​​("0123456789" [- r]);

8 Here is free space

There are many places that may make C programmers mistaken into lost. If you find it, please contact the author. It will be included in the later version, and add a footnote expressed gratitude.

reference

"THE C Programming Language" is the most authoritative C work. It contains an excellent tutorial for those who are familiar with other senior language programming, and a reference manual, simply describe the entire language. Although this language has undergone many changes since 1978, this book is still a pavilion for many themes. This book also includes "C Language Reference Manual" mentioned many times in this article.

"The C Puzzle Book" (Feuer, Prentice-Hall, 1982) is a book that is rarely cultivating people's ability. This book collected a lot of puzzles (and answers), and their solutions can test knowledge about the readers' somewhere in C language.

"C: a referenct manual" (Harbison and Stele, Prentice Hall 1984) is a reference for realizes. Others will also find it is especially useful - because he can refer to the details.

footnote