Learn to develop and use open-source software, including WordPress...

Welcome to a new generation of Drupal. It’s a digital experience...

Chapter 2 - Types, Operators and Expressions

Variables and constants are the basic data objects manipulated in a program. Declarations list the variables to be used, and state what type they have and perhaps what their initial values are. Operators specify what is to be done to them. Expressions combine variables and constants to produce new values.

The type of an object determines the set of values it can have and what operations can be performed on it. These building blocks are the topics of this chapter.

The ANSI standard has made many small changes and additions to basic types and expressions. There are now signedand unsignedforms of all integer types, and notations for unsigned constants and hexadecimal character constants. Floating-point operations may be done in single precision; there is also a longdouble type for extended precision. String constants may be concatenated at compile time. Enumerations have become part of the language, formalizing a feature of long standing. Objects may be declared const, which prevents them from being changed. The rules for automatic coercions among arithmetic types have been augmented to handle the richer set of types.

2.1 Variable Names

Although we didn't say so in Chapter 1, there are some restrictions on the names of variables and symbolic constants. Names are made up of letters and digits; the first character must be a letter. The underscore ``_'' counts as a letter; it is sometimes useful for improving the readability of long variable names. Don't begin variable names with underscore, however, since library routines often use such names. Upper and lower case letters are distinct, so xand Xare two different names. Traditional C practice is to use lower case for variable names, and all upper case for symbolic constants.

At least the first 31 characters of an internal name are significant. For function names and external variables, the number may be less than 31, because external names may be used by assemblers and loaders over which the language has no control. For external names, the standard guarantees uniqueness only for 6 characters and a single case. Keywords like if, else, int, float, etc., are reserved: you can't use them as variable names. They must be in lower case.

It's wise to choose variable names that are related to the purpose of the variable, and that are unlikely to get mixed up typographically. We tend to use short names for local variables, especially loop indices, and longer names for external variables.

2.2 Data Types and Sizes

There are only a few basic data types in C:

char a single byte, capable of holding one character in the local character set intan integer, typically reflecting the natural size of integers on the host machine float single-precision floating point double double-precision floating point

In addition, there are a number of qualifiers that can be applied to these basic types. shortand longapply to integers:

   short int sh;    long int counter;

The word intcan be omitted in such declarations, and typically it is.

The intent is that shortand longshould provide different lengths of integers where practical; intwill normally be the natural size for a particular machine. shortis often 16 bits long, and inteither 16 or 32 bits. Each compiler is free to choose appropriate sizes for its own hardware, subject only to the the restriction that shorts and ints are at least 16 bits, longs are at least 32 bits, and shortis no longer than int, which is no longer than long.

The qualifier signedor unsignedmay be applied to charor any integer. unsignednumbers are always positive or zero, and obey the laws of arithmetic modulo 2n, where n is the number of bits in the type. So, for instance, if chars are 8 bits, unsigned charvariables have values between 0 and 255, while signed chars have values between -128 and 127 (in a two's complement machine.) Whether plain chars are signed or unsigned is machine-dependent, but printable characters are always positive.

The type long doublespecifies extended-precision floating point. As with integers, the sizes of floating-point objects are implementation-defined; float, doubleand long doublecould represent one, two or three distinct sizes.

The standard headers <limits.h>and <float.h>contain symbolic constants for all of these sizes, along with other properties of the machine and compiler. These are discussed in Appendix B.

Exercise 2-1.Write a program to determine the ranges of char, short, int, and longvariables, both signedand unsigned, by printing appropriate values from standard headers and by direct computation. Harder if you compute them: determine the ranges of the various floating-point types.

2.3 Constants

An integer constant like 1234is an int. A longconstant is written with a terminal l(ell) or L, as in 123456789L; an integer constant too big to fit into an intwill also be taken as a long. Unsigned constants are written with a terminal uor U, and the suffix ulor ULindicates unsigned long.

Floating-point constants contain a decimal point (123.4) or an exponent (1e-2) or both; their type is double, unless suffixed. The suffixes for Findicate a floatconstant; lor Lindicate a long double.

The value of an integer can be specified in octal or hexadecimal instead of decimal. A leading 0(zero) on an integer constant means octal; a leading 0xor 0Xmeans hexadecimal. For example, decimal 31 can be written as 037in octal and 0x1for 0x1Fin hex. Octal and hexadecimal constants may also be followed by Lto make them longand Uto make them unsigned: 0XFULis an unsigned long constant with value 15 decimal.

A character constantis an integer, written as one character within single quotes, such as 'x'. The value of a character constant is the numeric value of the character in the machine's character set. For example, in the ASCII character set the character constant '0'has the value 48, which is unrelated to the numeric value 0. If we write '0'instead of a numeric value like 48 that depends on the character set, the program is independent of the particular value and easier to read. Character constants participate in numeric operations just as any other integers, although they are most often used in comparisons with other characters.

Certain characters can be represented in character and string constants by escape sequences like \n(newline); these sequences look like two characters, but represent only one. In addition, an arbitrary bytesized bit pattern can be specified by

   '\ooo'

where ooo is one to three octal digits (0...7) or by

   '\xhh'

where hh is one or more hexadecimal digits (0...9, a...f, A...F). So we might write

   #define VTAB '\013'   /* ASCII vertical tab */

   #define BELL '\007'   /* ASCII bell character */

or, in hexadecimal,

   #define VTAB '\xb'   /* ASCII vertical tab */

   #define BELL '\x7'   /* ASCII bell character */

The complete set of escape sequences is

 \a alert (bell) character  \\  backslash

                                                              \b  backspace                     \?question mark

                                                              \f  formfeed                        \'single quote

                                                              \n  newline                      \"      double quote

                                                              \r carriage return           \ooo octal number

                                                              \t  horizontal tab            \xhh  hexadecimal number

 \v  vertical tab

The character constant '\0'represents the character with value zero, the null character. '\0'is often written instead of 0to emphasize the character nature of some expression, but the numeric value is just 0.

A constant expression is an expression that involves only constants. Such expressions may be evaluated at during compilation rather than run-time, and accordingly may be used in any place that a constant can occur, as in

   #define MAXLINE 1000    char line[MAXLINE+1];

or

   #define LEAP 1 /* in leap years */

   int days[31+28+LEAP+31+30+31+30+31+31+30+31+30+31];

A string constant, or string literal, is a sequence of zero or more characters surrounded by double quotes, as in

   "I am a string"

or

   "" /* the empty string */

The quotes are not part of the string, but serve only to delimit it. The same escape sequences used in character constants apply in strings; \"represents the double-quote character. String constants can be concatenated at compile time:

   "hello, " "world"

is equivalent to

   "hello, world"

This is useful for splitting up long strings across several source lines.

Technically, a string constant is an array of characters. The internal representation of a string has a null character '\0'at the end, so the physical storage required is one more than the number of characters written between the quotes. This representation means that there is no limit to how long a string can be, but programs must scan a string completely to determine its length. The standard library function strlen(s)returns the length of its character string argument s, excluding the terminal '\0'. Here is our version:

   /* strlen:  return length of s */    int strlen(char s[])    {        int i;

       while (s[i] != '\0')            ++i;        return i;    }

strlenand other string functions are declared in the standard header <string.h>.

Be careful to distinguish between a character constant and a string that contains a single character: 'x'is not the same as "x". The former is an integer, used to produce the numeric value of the letter x in the machine's character set. The latter is an array of characters that contains one character (the letter x) and a '\0'.

There is one other kind of constant, the enumeration constant. An enumeration is a list of constant integer values, as in

   enum boolean { NO, YES };

The first name in an enumhas value 0, the next 1, and so on, unless explicit values are specified. If not all values are specified, unspecified values continue the progression from the last specified value, as the second of these examples:

   enum escapes { BELL = '\a', BACKSPACE = '\b', TAB = '\t',                   NEWLINE = '\n', VTAB = '\v', RETURN = '\r' };

   enum months { JAN = 1, FEB, MAR, APR, MAY, JUN,                  JUL, AUG, SEP, OCT, NOV, DEC };

                       /* FEB = 2, MAR = 3, etc. */

Names in different enumerations must be distinct. Values need not be distinct in the same enumeration.

Enumerations provide a convenient way to associate constant values with names, an alternative to

#definewith the advantage that the values can be generated for you. Although variables of enumtypes may be declared, compilers need not check that what you store in such a variable is a valid value for the enumeration. Nevertheless, enumeration variables offer the chance of checking and so are often better than #defines. In addition, a debugger may be able to print values of enumeration variables in their symbolic form.

2.4 Declarations

All variables must be declared before use, although certain declarations can be made implicitly by content. A declaration specifies a type, and contains a list of one or more variables of that type, as in

   int  lower, upper, step;    char c, line[1000];

Variables can be distributed among declarations in any fashion; the lists above could well be written as

   int  lower;    int  upper;    int  step;    char c;    char line[1000];

The latter form takes more space, but is convenient for adding a comment to each declaration for subsequent modifications.

A variable may also be initialized in its declaration. If the name is followed by an equals sign and an expression, the expression serves as an initializer, as in

   char  esc = '\\';    int   i = 0;    int   limit = MAXLINE+1;    float eps = 1.0e-5;

If the variable in question is not automatic, the initialization is done once only, conceptionally before the program starts executing, and the initializer must be a constant expression. An explicitly initialized automatic variable is initialized each time the function or block it is in is entered; the initializer may be any expression. External and static variables are initialized to zero by default. Automatic variables for which is no explicit initializer have undefined (i.e., garbage) values.

The qualifier constcan be applied to the declaration of any variable to specify that its value will not be changed. For an array, the constqualifier says that the elements will not be altered.

   const double e = 2.71828182845905;    const char msg[] = "warning: ";

The constdeclaration can also be used with array arguments, to indicate that the function does not change that array:

   int strlen(const char[]);

The result is implementation-defined if an attempt is made to change a const.

2.5 Arithmetic Operators

The binary arithmetic operators are +, -, *, /, and the modulus operator %. Integer division truncates any fractional part. The expression

   x % y

produces the remainder when xis divided by y, and thus is zero when ydivides xexactly. For example, a year is a leap year if it is divisible by 4 but not by 100, except that years divisible by 400 are leap years. Therefore

   if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)        printf("%d is a leap year\n", year);    else

       printf("%d is not a leap year\n", year);

The %operator cannot be applied to a floator double. The direction of truncation for /and the sign of the result for %are machine-dependent for negative operands, as is the action taken on overflow or underflow.

The binary +and -operators have the same precedence, which is lower than the precedence of *, /and %, which is in turn lower than unary +and -. Arithmetic operators associate left to right.

Table 2.1 at the end of this chapter summarizes precedence and associativity for all operators.

2.6 Relational and Logical Operators

The relational operators are

   >   >=   <   <=

They all have the same precedence. Just below them in precedence are the equality operators:

   ==   !=

Relational operators have lower precedence than arithmetic operators, so an expression like i < lim-1is taken as i < (lim-1), as would be expected.

More interesting are the logical operators &&and ||. Expressions connected by &&or ||are evaluated left to right, and evaluation stops as soon as the truth or falsehood of the result is known. Most C programs rely on these properties. For example, here is a loop from the input function getlinethat we wrote in Chapter 1:

   for (i=0; i < lim-1 && (c=getchar()) != '\n' && c != EOF; ++i)        s[i] = c;

Before reading a new character it is necessary to check that there is room to store it in the array s, so the test i < lim-1must be made first. Moreover, if this test fails, we must not go on and read another character.

Similarly, it would be unfortunate if cwere tested against EOFbefore getcharis called; therefore the call and assignment must occur before the character in cis tested.

The precedence of &&is higher than that of ||, and both are lower than relational and equality operators, so expressions like

   i < lim-1 && (c=getchar()) != '\n' && c != EOF

need no extra parentheses. But since the precedence of !=is higher than assignment, parentheses are needed in

   (c=getchar()) != '\n'

to achieve the desired result of assignment to cand then comparison with '\n'.

By definition, the numeric value of a relational or logical expression is 1 if the relation is true, and 0 if the relation is false.

The unary negation operator !converts a non-zero operand into 0, and a zero operand in 1. A common use of !is in constructions like

   if (!valid)

rather than

   if (valid == 0)

It's hard to generalize about which form is better. Constructions like !validread nicely (``if not valid''), but more complicated ones can be hard to understand.

Exercise 2-2.Write a loop equivalent to the forloop above without using &&or ||.

2.7 Type Conversions

When an operator has operands of different types, they are converted to a common type according to a small number of rules. In general, the only automatic conversions are those that convert a ``narrower'' operand into a ``wider'' one without losing information, such as converting an integer into floating point in an expression like f + i. Expressions that don't make sense, like using a floatas a subscript, are disallowed. Expressions that might lose information, like assigning a longer integer type to a shorter, or a floating-point type to an integer, may draw a warning, but they are not illegal.

A charis just a small integer, so chars may be freely used in arithmetic expressions. This permits considerable flexibility in certain kinds of character transformations. One is exemplified by this naive implementation of the function atoi, which converts a string of digits into its numeric equivalent.

   /* atoi:  convert s to integer */    int atoi(char s[])    {        int i, n;

       n = 0;        for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)            n = 10 * n + (s[i] - '0');        return n;    }

As we discussed in Chapter 1, the expression

    s[i] - '0'

gives the numeric value of the character stored in s[i], because the values of '0', '1', etc., form a contiguous increasing sequence.

Another example of charto intconversion is the function lower, which maps a single character to lower case for the ASCII character set. If the character is not an upper case letter, lowerreturns it unchanged.

   /* lower:  convert c to lower case; ASCII only */    int lower(int c)    {        if (c >= 'A' && c <= 'Z')            return c + 'a' - 'A';        else            return c;    }

This works for ASCII because corresponding upper case and lower case letters are a fixed distance apart as numeric values and each alphabet is contiguous -- there is nothing but letters between Aand Z. This latter observation is not true of the EBCDIC character set, however, so this code would convert more than just letters in EBCDIC.

The standard header <ctype.h>, described in Appendix B, defines a family of functions that provide tests and conversions that are independent of character set. For example, the function toloweris a portable replacement for the function lowershown above. Similarly, the test

   c >= '0' && c <= '9'

can be replaced by

   isdigit(c)

We will use the <ctype.h>functions from now on.

There is one subtle point about the conversion of characters to integers. The language does not specify whether variables of type charare signed or unsigned quantities. When a charis converted to an int, can it ever produce a negative integer? The answer varies from machine to machine, reflecting differences in architecture. On some machines a charwhose leftmost bit is 1 will be converted to a negative integer (``sign extension''). On others, a charis promoted to an int by adding zeros at the left end, and thus is always positive.

The definition of C guarantees that any character in the machine's standard printing character set will never be negative, so these characters will always be positive quantities in expressions. But arbitrary bit patterns stored in character variables may appear to be negative on some machines, yet positive on others. For portability, specify signedor unsignedif non-character data is to be stored in charvariables.

Relational expressions like i > jand logical expressions connected by &&and ||are defined to have value 1 if true, and 0 if false. Thus the assignment

   d = c >= '0' && c <= '9'

sets dto 1 if cis a digit, and 0 if not. However, functions like isdigitmay return any non-zero value for true. In the test part of if, while, for, etc., ``true'' just means ``non-zero'', so this makes no difference.

Implicit arithmetic conversions work much as expected. In general, if an operator like +or *that takes two operands (a binary operator) has operands of different types, the ``lower'' type is promoted to the ``higher'' type before the operation proceeds. The result is of the integer type. Section 6 of Appendix Astates the conversion rules precisely. If there are no unsignedoperands, however, the following informal set of rules will suffice:

  • If either operand is long double, convert the other to long double.
  • Otherwise, if either operand is double, convert the other to double.
  • Otherwise, if either operand is float, convert the other to float.
  • Otherwise, convert charand shortto int.
  • Then, if either operand is long, convert the other to long.

Notice that floats in an expression are not automatically converted to double; this is a change from the original definition. In general, mathematical functions like those in <math.h>will use double precision. The main reason for using floatis to save storage in large arrays, or, less often, to save time on machines where double-precision arithmetic is particularly expensive.

Conversion rules are more complicated when unsignedoperands are involved. The problem is that comparisons between signed and unsigned values are machine-dependent, because they depend on the sizes of the various integer types. For example, suppose that intis 16 bits and longis 32 bits. Then -

1L < 1U, because 1U, which is an unsigned int, is promoted to a signed long. But -1L > 1ULbecause -1Lis promoted to unsigned longand thus appears to be a large positive number.

Conversions take place across assignments; the value of the right side is converted to the type of the left, which is the type of the result.

A character is converted to an integer, either by sign extension or not, as described above.

Longer integers are converted to shorter ones or to chars by dropping the excess high-order bits. Thus in

   int  i;    char c;

   i = c;    c = i;

the value of cis unchanged. This is true whether or not sign extension is involved. Reversing the order of assignments might lose information, however.

If xis floatand iis int, then x = iand i = xboth cause conversions; floatto intcauses truncation of any fractional part. When a doubleis converted to float, whether the value is rounded or truncated is implementation dependent.

Since an argument of a function call is an expression, type conversion also takes place when arguments are passed to functions. In the absence of a function prototype, charand shortbecome int, and floatbecomes double. This is why we have declared function arguments to be intand doubleeven when the function is called with charand float.

Finally, explicit type conversions can be forced (``coerced'') in any expression, with a unary operator called a cast. In the construction

  (type name) expression

the expression is converted to the named type by the conversion rules above. The precise meaning of a cast is as if the expression were assigned to a variable of the specified type, which is then used in place of the whole construction. For example, the library routine sqrtexpects a doubleargument, and will produce nonsense if inadvertently handled something else. (sqrtis declared in <math.h>.) So if nis an integer, we can use

   sqrt((double) n)

to convert the value of nto doublebefore passing it to sqrt. Note that the cast produces the value of nin the proper type; nitself is not altered. The cast operator has the same high precedence as other unary operators, as summarized in the table at the end of this chapter.

If arguments are declared by a function prototype, as the normally should be, the declaration causes automatic coercion of any arguments when the function is called. Thus, given a function prototype for sqrt:

   double sqrt(double)

the call

   root2 = sqrt(2)

coerces the integer 2into the doublevalue 2.0without any need for a cast.

The standard library includes a portable implementation of a pseudo-random number generator and a function for initializing the seed; the former illustrates a cast:

   unsigned long int next = 1;

   /* rand:  return pseudo-random integer on 0..32767 */    int rand(void)    {        next = next * 1103515245 + 12345;        return (unsigned int)(next/65536) % 32768;    }

   /* srand:  set seed for rand() */    void srand(unsigned int seed)    {

       next = seed;    }

Exercise 2-3.Write a function htoi(s), which converts a string of hexadecimal digits (including an optional 0xor 0X) into its equivalent integer value. The allowable digits are 0through 9, athrough f, and Athrough F.

2.8 Increment and Decrement Operators

C provides two unusual operators for incrementing and decrementing variables. The increment operator

++adds 1 to its operand, while the decrement operator --subtracts 1. We have frequently used ++to increment variables, as in

   if (c == '\n')        ++nl;

The unusual aspect is that ++and --may be used either as prefix operators (before the variable, as in ++n), or postfix operators (after the variable: n++). In both cases, the effect is to increment n. But the expression ++nincrements nbefore its value is used, while n++increments nafter its value has been used. This means that in a context where the value is being used, not just the effect, ++nand n++are different. If nis 5, then

   x = n++;

sets xto 5, but

   x = ++n;

sets xto 6. In both cases, nbecomes 6. The increment and decrement operators can only be applied to variables; an expression like (i+j)++is illegal.

In a context where no value is wanted, just the incrementing effect, as in

   if (c == '\n')        nl++;

prefix and postfix are the same. But there are situations where one or the other is specifically called for. For instance, consider the function squeeze(s,c), which removes all occurrences of the character cfrom the string s.

   /* squeeze:  delete all c from s */    void squeeze(char s[], int c)    {       int i, j;

      for (i = j = 0; s[i] != '\0'; i++)           if (s[i] != c)               s[j++] = s[i];       s[j] = '\0';    }

Each time a non-coccurs, it is copied into the current jposition, and only then is jincremented to be ready for the next character. This is exactly equivalent to

   if (s[i] != c) {        s[j] = s[i];        j++;    }

Another example of a similar construction comes from the getlinefunction that we wrote in Chapter

1, where we can replace

   if (c == '\n') {        s[i] = c;        ++i;

   }

by the more compact

   if (c == '\n')       s[i++] = c;

As a third example, consider the standard function strcat(s,t), which concatenates the string tto the end of string s. strcatassumes that there is enough space in sto hold the combination. As we have written it, strcatreturns no value; the standard library version returns a pointer to the resulting string.

   /* strcat:  concatenate t to end of s; s must be big enough */    void strcat(char s[], char t[])    {        int i, j;

       i = j = 0;        while (s[i] != '\0') /* find end of s */            i++;        while ((s[i++] = t[j++]) != '\0') /* copy t */            ;

   }

As each member is copied from tto s, the postfix ++is applied to both iand jto make sure that they are in position for the next pass through the loop.

Exercise 2-4.Write an alternative version of squeeze(s1,s2)that deletes each character in s1that matches any character in the string s2.

Exercise 2-5.Write the function any(s1,s2), which returns the first location in a string s1where any character from the string s2occurs, or -1if s1contains no characters from s2. (The standard library function strpbrkdoes the same job but returns a pointer to the location.)

2.9 Bitwise Operators

C provides six operators for bit manipulation; these may only be applied to integral operands, that is, char, short, int, and long, whether signed or unsigned.

& bitwise AND

| bitwise inclusive OR

^ bitwise exclusive OR

<<  left shift

>> right shift

~ one's complement (unary)

The bitwise AND operator &is often used to mask off some set of bits, for example

   n = n & 0177;

sets to zero all but the low-order 7 bits of n.

The bitwise OR operator |is used to turn bits on:

   x = x | SET_ON;

sets to one in xthe bits that are set to one in SET_ON.

The bitwise exclusive OR operator ^sets a one in each bit position where its operands have different bits, and zero where they are the same.

One must distinguish the bitwise operators &and |from the logical operators &&and ||, which imply left-to-right evaluation of a truth value. For example, if xis 1 and yis 2, then x & yis zero while x && yis one.

The shift operators <<and >>perform left and right shifts of their left operand by the number of bit positions given by the right operand, which must be non-negative. Thus x << 2shifts the value of xby two positions, filling vacated bits with zero; this is equivalent to multiplication by 4. Right shifting an unsignedquantity always fits the vacated bits with zero. Right shifting a signed quantity will fill with bit signs (``arithmetic shift'') on some machines and with 0-bits (``logical shift'') on others.

The unary operator ~yields the one's complement of an integer; that is, it converts each 1-bit into a 0-bit and vice versa. For example

   x = x & ~077

sets the last six bits of xto zero. Note that x & ~077is independent of word length, and is thus preferable to, for example, x & 0177700, which assumes that xis a 16-bit quantity. The portable form involves no extra cost, since ~077is a constant expression that can be evaluated at compile time.

As an illustration of some of the bit operators, consider the function getbits(x,p,n)that returns the (right adjusted) n-bit field of xthat begins at position p. We assume that bit position 0 is at the right end and that nand pare sensible positive values. For example, getbits(x,4,3)returns the three bits in positions 4, 3 and 2, right-adjusted.

   /* getbits:  get n bits from position p */    unsigned getbits(unsigned x, int p, int n)    {        return (x >> (p+1-n)) & ~(~0 << n);    }

The expression x >> (p+1-n)moves the desired field to the right end of the word. ~0is all 1-bits; shifting it left npositions with ~0<<nplaces zeros in the rightmost nbits; complementing that with ~makes a mask with ones in the rightmost nbits.

Exercise 2-6.Write a function setbits(x,p,n,y)that returns xwith the nbits that begin at position pset to the rightmost nbits of y, leaving the other bits unchanged.

Exercise 2-7.Write a function invert(x,p,n)that returns xwith the nbits that begin at position pinverted (i.e., 1 changed into 0 and vice versa), leaving the others unchanged.

Exercise 2-8.Write a function rightrot(x,n)that returns the value of the integer xrotated to the right by npositions.

2.10 Assignment Operators and Expressions

An expression such as

   i = i + 2

in which the variable on the left side is repeated immediately on the right, can be written in the compressed form

   i += 2

The operator +=is called an assignment operator.

Most binary operators (operators like +that have a left and right operand) have a corresponding assignment operator op=, where op is one of

   +   -   *   /   %   <<   >>   &   ^   |

If expr1and expr2are expressions, then

   expr1op= expr2

is equivalent to

   expr1= (expr1) op (expr2)

except that expr1is computed only once. Notice the parentheses around expr2:

   x *= y + 1

means

   x = x * (y + 1)

rather than

   x = x * y + 1

As an example, the function bitcountcounts the number of 1-bits in its integer argument.

   /* bitcount:  count 1 bits in x */    int bitcount(unsigned x)    {        int b;

       for (b = 0; x != 0; x >>= 1)            if (x & 01)

               b++;        return b;    }

Declaring the argument xto be an unsignedensures that when it is right-shifted, vacated bits will be filled with zeros, not sign bits, regardless of the machine the program is run on.

Quite apart from conciseness, assignment operators have the advantage that they correspond better to the way people think. We say ``add 2 to i'' or ``increment iby 2'', not ``take i, add 2, then put the result back in i''. Thus the expression i += 2is preferable to i = i+2. In addition, for a complicated expression like

   yyval[yypv[p3+p4] + yypv[p1]] += 2

the assignment operator makes the code easier to understand, since the reader doesn't have to check painstakingly that two long expressions are indeed the same, or to wonder why they're not. And an assignment operator may even help a compiler to produce efficient code.

We have already seen that the assignment statement has a value and can occur in expressions; the most common example is

   while ((c = getchar()) != EOF)        ...

The other assignment operators (+=, -=, etc.) can also occur in expressions, although this is less frequent.

In all such expressions, the type of an assignment expression is the type of its left operand, and the value is the value after the assignment.

Exercise 2-9.In a two's complement number system, x &= (x-1)deletes the rightmost 1-bit in x. Explain why. Use this observation to write a faster version of bitcount.

2.11 Conditional Expressions

The statements

   if (a > b)        z = a;    else        z = b; compute in zthe maximum of aand b. The conditional expression, written with the ternary operator

``?:'', provides an alternate way to write this and similar constructions. In the expression

   expr1? expr2: expr3

the expression expr1is evaluated first. If it is non-zero (true), then the expression expr2is evaluated, and that is the value of the conditional expression. Otherwise expr3is evaluated, and that is the value. Only one of expr2and expr3is evaluated. Thus to set zto the maximum of aand b,

   z = (a > b) ? a : b;    /* z = max(a, b) */

It should be noted that the conditional expression is indeed an expression, and it can be used wherever any other expression can be. If expr2and expr3are of different types, the type of the result is determined by the conversion rules discussed earlier in this chapter. For example, if fis a floatand nan int, then the expression

   (n > 0) ? f : n

is of type floatregardless of whether nis positive.

Parentheses are not necessary around the first expression of a conditional expression, since the precedence of ?:is very low, just above assignment. They are advisable anyway, however, since they make the condition part of the expression easier to see.

The conditional expression often leads to succinct code. For example, this loop prints nelements of an array, 10 per line, with each column separated by one blank, and with each line (including the last) terminated by a newline.

   for (i = 0; i < n; i++)

       printf("%6d%c", a[i], (i%10==9 || i==n-1) ? '\n' : ' ');

A newline is printed after every tenth element, and after the n-th. All other elements are followed by one blank. This might look tricky, but it's more compact than the equivalent if-else. Another good example is

   printf("You have %d items%s.\n", n, n==1 ? "" : "s");

Exercise 2-10.Rewrite the function lower, which converts upper case letters to lower case, with a conditional expression instead of if-else.

2.12 Precedence and Order of Evaluation

Table 2.1 summarizes the rules for precedence and associativity of all operators, including those that we have not yet discussed. Operators on the same line have the same precedence; rows are in order of decreasing precedence, so, for example, *, /, and %all have the same precedence, which is higher than that of binary +and -. The ``operator'' ()refers to function call. The operators ->and .are used to access members of structures; they will be covered in Chapter 6, along with sizeof(size of an object). Chapter 5discusses *(indirection through a pointer) and &(address of an object), and Chapter 3discusses the comma operator.

Unary & +, -, and * have higher precedence than the binary forms.

Table 2.1:Precedence and Associativity of Operators

Note that the precedence of the bitwise operators &, ^, and |falls below ==and !=. This implies that bittesting expressions like

   if ((x & MASK) == 0) ...

must be fully parenthesized to give proper results.

C, like most languages, does not specify the order in which the operands of an operator are evaluated.

(The exceptions are &&, ||, ?:, and `,'.) For example, in a statement like

   x = f() + g();

fmay be evaluated before gor vice versa; thus if either for galters a variable on which the other depends, xcan depend on the order of evaluation. Intermediate results can be stored in temporary variables to ensure a particular sequence.

Similarly, the order in which function arguments are evaluated is not specified, so the statement

   printf("%d %d\n", ++n, power(2, n));   /* WRONG */

can produce different results with different compilers, depending on whether nis incremented before poweris called. The solution, of course, is to write

   ++n;

   printf("%d %d\n", n, power(2, n));

Function calls, nested assignment statements, and increment and decrement operators cause ``side effects'' - some variable is changed as a by-product of the evaluation of an expression. In any expression involving side effects, there can be subtle dependencies on the order in which variables taking part in the expression are updated. One unhappy situation is typified by the statement

   a[i] = i++;

The question is whether the subscript is the old value of ior the new. Compilers can interpret this in different ways, and generate different answers depending on their interpretation. The standard intentionally leaves most such matters unspecified. When side effects (assignment to variables) take place within an expression is left to the discretion of the compiler, since the best order depends strongly on machine architecture. (The standard does specify that all side effects on arguments take effect before a function is called, but that would not help in the call to printfabove.)

The moral is that writing code that depends on order of evaluation is a bad programming practice in any language. Naturally, it is necessary to know what things to avoid, but if you don't know how they are done on various machines, you won't be tempted to take advantage of a particular implementation.

Computer Courses

Get in touch with us

FIZIKA MIND

Best website developer in bareilly

Contact us

FIZIKA MIND.

Kipps Enclave Shastri Nagar Bareilly, IN

Cont. no. +91-9259436235
[email protected]

Join our mailing list

Signup for Our Free Newsletter
Education - This is a contributing Drupal Theme
Design by WeebPal.