New Google Search

WOW: Google to Launch a New Version of Google Search Google has a giant target on its back. Microsoft has been on a spending and deal-making spree to grow Bing, recently signing a huge search deal with Yahoo. And with Bing starting to steal some market share from Google, it’s proving to be a formidable opponent. Oh, and now you can’t count out Facebook either, which just launched a new realtime search engine.Google’s not taking any...

Read More

9.3 Conditional Compilation

9.3 Conditional Compilation [This section corresponds to K&R Sec. 4.11.3] The last preprocessor directive we're going to look at is #ifdef. If you have the sequence #ifdef name program text #else more program text #endif in your program, the code that gets compiled depends on whether a preprocessor macro by that name is defined or not. If it is (that is, if there has been a #define line for a macro called name), then ``program text'' is compiled and ``more program text'' is ignored. If the macro is not defined, ``more program text'' is compiled and ``program text'' is ignored. This looks a lot like an if statement, but it behaves...

Read More

9.2 Macro Definition and Substitution

9.2 Macro Definition and Substitution [This section corresponds to K&R Sec. 4.11.2] A preprocessor line of the form #define name text defines a macro with the given name, having as its value the given replacement text. After that (for the rest of the current source file), wherever the preprocessor sees that name, it will replace it with the replacement text. The name follows the same rules as ordinary identifiers (it can contain only letters, digits, and underscores, and may not begin with a digit). Since macros behave quite differently from normal variables (or functions), it is customary to give them names which are all capital letters...

Read More

9.1 File Inclusion

9.1 File Inclusion [This section corresponds to K&R Sec. 4.11.1] A line of the form #include <filename.h> or #include "filename.h" causes the contents of the file filename.h to be read, parsed, and compiled at that point. (After filename.h is processed, compilation continues on the line following the #include line.) For example, suppose you got tired of retyping external function prototypes such as extern int getline(char [], int); at the top of each source file. You could instead place the prototype in a header file, perhaps getline.h, and then simply place #include "getline.h" at the top of each source file where you called...

Read More

Chapter 9: The C Preprocessor

Chapter 9: The C Preprocessor Conceptually, the ``preprocessor'' is a translation phase that is applied to your source code before the compiler proper gets its hands on it. (Once upon a time, the preprocessor was a separate program, much as the compiler and linker may still be separate programs today.) Generally, the preprocessor performs textual substitutions on your source code, in three sorts of ways: File inclusion: inserting the contents of another file into your source file, as if you had typed it all in there. Macro substitution: replacing instances of one piece of text with another. Conditional compilation: Arranging that, depending...

Read More

Chapter 8: Strings

Chapter 8: Strings Strings in C are represented by arrays of characters. The end of the string is marked with a special character, the null character, which is simply the character with the value 0. (The null character has no relation except in name to the null pointer. In the ASCII character set, the null character is named NUL.) The null or string-terminating character is represented by another character escape sequence, \0. (We've seen it once already, in the getline function of chapter 6.) Because C has no built-in facilities for manipulating entire arrays (copying them, comparing them, etc.), it also has very few built-in facilities for...

Read More

7.3 Order of Evaluation

7.3 Order of Evaluation [This section corresponds to K&R Sec. 2.12] When you start using the ++ and -- operators in larger expressions, you end up with expressions which do several things at once, i.e., they modify several different variables at more or less the same time. When you write such an expression, you must be careful not to have the expression ``pull the rug out from under itself'' by assigning two different values to the same variable, or by assigning a new value to a variable at the same time that another part of the expression is trying to use the value of that variable. Actually, we had already started writing expressions...

Read More

7.2 Increment and Decrement Operators

7.2 Increment and Decrement Operators [This section corresponds to K&R Sec. 2.8] The assignment operators of the previous section let us replace v = v op e with v op= e, so that we didn't have to mention v twice. In the most common cases, namely when we're adding or subtracting the constant 1 (that is, when op is + or - and e is 1), C provides another set of shortcuts: the autoincrement and autodecrement operators. In their simplest forms, they look like this: ++i add 1 to i --j subtract 1 from j These correspond to the slightly longer i += 1 and j -= 1, respectively, and also to the fully ``longhand'' forms i = i + 1 and j = j -...

Read More

7.1 Assignment Operators

7.1 Assignment Operators [This section corresponds to K&R Sec. 2.10] The first and more general way is that any time you have the pattern v = v op e where v is any variable (or anything like a[i]), op is any of the binary arithmetic operators we've seen so far, and e is any expression, you can replace it with the simplified v op= e For example, you can replace the expressions i = i + 1 j = j - 10 k = k * (n + 1) a[i] = a[i] / b with i += 1 j -= 10 k *= n + 1 a[i] /= b In an example in a previous chapter, we used the assignment a[d1 + d2] = a[d1 + d2] + 1; to count the rolls of a pair of dice. Using +=, we could simplify this...

Read More

Chapter 7: More Operators

Chapter 7: More Operators In this chapter we'll meet some (though still not all) of C's more advanced arithmetic operators. The ones we'll meet here have to do with making common patterns of operations easier. It's extremely common in programming to have to increment a variable by 1, that is, to add 1 to it. (For example, if you're processing each element of an array, you'll typically write a loop with an index or pointer variable stepping through the elements of the array, and you'll increment the variable each time through the loop.) The classic way to increment a variable is with an assignment like i = i + 1 Such an assignment is perfectly...

Read More

6.4 Reading Numbers

6.4 Reading Numbers The getline function of the previous section reads one line from the user, as a string. What if we want to read a number? One straightforward way is to read a string as before, and then immediately convert the string to a number. The standard C library contains a number of functions for doing this. The simplest to use are atoi(), which converts a string to an integer, and atof(), which converts a string to a floating-point number. (Both of these functions are declared in the header <stdlib.h>, so you should #include that header at the top of any file using these functions.) You could read an integer from the user like...

Read More

6.3 Reading Lines

6.3 Reading Lines It's often convenient for a program to process its input not a character at a time but rather a line at a time, that is, to read an entire line of input and then act on it all at once. The standard C library has a couple of functions for reading lines, but they have a few awkward features, so we're going to learn more about character input (and about writing functions in general) by writing our own function to read one line. Here it is: #include <stdio.h> /* Read one line from standard input, */ /* copying it to line array (but no more than max chars). */ /* Does not place terminating \n in line array. */ /* Returns...

Read More

6.2 Character Input and Output

6.2 Character Input and Output [This section corresponds to K&R Sec. 1.5] Unless a program can read some input, it's hard to keep it from doing exactly the same thing every time it's run, and thus being rather boring after a while. The most basic way of reading input is by calling the function getchar. getchar reads one character from the ``standard input,'' which is usually the user's keyboard, but which can sometimes be redirected by the operating system. getchar returns (rather obviously) the character it reads, or, if there are no more characters available, the special value EOF (``end of file''). A companion function is putchar,...

Read More