C For Dummies

( 2 )

Overview

Come "C" what all the excitement's about! C programs are fast, concise, and versatile, and you'll be writing them in no time. This friendly book unlocks the mysteries of coding, compiling, adding comments, and using keywords, I/O, variables, integers, and all the rest. You'll write your first C program before you finish Chapter 1!
Read More Show Less
... See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (26) from $1.99   
  • New (3) from $12.40   
  • Used (23) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$12.40
Seller since 2008

Feedback rating:

(169)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
156884915X BRAND NEW NEVER USED IN STOCK 125,000+ HAPPY CUSTOMERS SHIP EVERY DAY WITH FREE TRACKING NUMBER

Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$45.00
Seller since 2014

Feedback rating:

(148)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$50.00
Seller since 2014

Feedback rating:

(148)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Close
Sort by
Sending request ...

Overview

Come "C" what all the excitement's about! C programs are fast, concise, and versatile, and you'll be writing them in no time. This friendly book unlocks the mysteries of coding, compiling, adding comments, and using keywords, I/O, variables, integers, and all the rest. You'll write your first C program before you finish Chapter 1!
Read More Show Less

Product Details

  • ISBN-13: 9781568849157
  • Publisher: Wiley
  • Publication date: 4/29/1997
  • Series: For Dummies Series
  • Edition description: Older Edition
  • Edition number: 1
  • Pages: 552
  • Product dimensions: 7.42 (w) x 9.27 (h) x 1.36 (d)

Table of Contents

Introduction 1
Pt. I Introduction to C programming 7
Ch. 1 Up from the primordial C 9
Ch. 2 C of sorrow, C of woe 19
Ch. 3 C straight 29
Ch. 4 C what I/O 39
Ch. 5 To C or not to C 55
Ch. 6 C more I/O with gets() and puts() 65
Pt. II Run and scream for variables and math 73
Ch. 7 A + B = C 75
Ch. 8 Charting unknown Cs with variables 93
Ch. 9 How to C numbers 107
Ch. 10 Cook that C variable charred, please 121
Pt. III Giving your programs the ability to run amok 131
Ch. 11 C more math and the sacred order of precedence 133
Ch. 12 C the mighty if command 147
Ch. 13 What if C = C? 165
Ch. 14 Iffy C logic 175
Ch. 15 C you again 185
Ch. 16 C the loop, C the loop++ 201
Ch. 17 C you in a while loop 215
Ch. 18 Do C while you sleep 225
Ch. 19 Switch case, or, from 'C' to shinning 'c' 239
Pt. IV C level 251
Ch. 20 Writing that first function 253
Ch. 21 Contending with variables in functions 265
Ch. 22 Functions that actually funct 275
Ch. 23 The stuff that comes first 293
Ch. 24 The printf() chapter 305
Ch. 25 Math madness! 313
Ch. 26 The old random-number function 325
Pt. V Part of tens 337
Ch. 27 Ten more things you need to know about the C language 339
Ch. 28 Ten tips for the budding programmer 347
Ch. 29 Ten ways to solve your own programming problems 353
App. A: The stuff you need to know before you read all the other stuff in this book 359
App. B: ASCII table 371
Index 377
Read More Show Less

First Chapter

Lesson 9-1: Asking for Arrays

Array is one of those words that loses its meaning the more you say it. Array. A ray. Air ray. Hairy. Hooray!

An array is nothing more than an organized collection of stuff. Suppose that you're decorating cookies, and, because you're obsessively neat, you have arranged them into two lines: one ready for decorating and another already decorated. Nerdy folk would say that you have two arrays of cookies. C programmers would say that you have an initialized array (decorated cookies) and an uninitialized array (undecorated cookies). Me? I would just eat the cookies and suck the raw frosting from the decorating tube.

What does all this mean? Nothing more than identifying a collection of stuff with the word array.

  • An array is a collection of stuff, like a row of cookies or a list of items in a column or a line of cars backed up seven miles on the freeway.
  • You can cheerfully ignore the terms initialized and uninitialized for now.
  • Arrays open up the heretofore unexplored region of database programming in C. Because an array is essentially a collection of stuff in a database, you can do databasey things with arrays: List them, sort them, unsort them, create bogus databases for the IRS, and so on.
  • It's the database manipulation that makes arrays so handy.

The whole deal with arrays

In the C language, an array is a collection of variables, all of the same type. You can have an array of integers, single-character variables, floats, doubles, and so on.

Alas, you can't have an array of strings -- not yet, anyway. You have enough to do with integer arrays to keep you busy for this lesson.

Suppose that a bunch of football jocks are standing in line at the school café. Since you're standing behind them, they'll probably hoard all the good food before you get there. But that's not the point. What you should notice instead are the numbers printed across the back of their jerseys.

Unbeknownst to the football players, integers are printed on their jerseys. (They know that they have numbers on their jerseys, but not all of them know that the numbers are integers.) Standing there, they make up, in a way, an integer array, which you could write like this:

16, 88, 45, 99, 6, 33

Hike!

You could also make an array from their names -- a string array:

Sherman, Fernan, Hastings, Harrison, Best, Hayden

Then you could make an array from the first letter of their girlfriend's names:

S, E, K, K, K, K

(Kelly is very popular.)

Each of these three examples is an array. The examples are a collection of items all of the same type: integers, strings, and characters.

Now for the nerdy terms:

Element: Each item in an array is called an element. The array can have as many elements as it needs (although in your computer the true size is limited by how much memory your PC has). In the preceding example, each of the arrays contains six elements: six jersey numbers, six names, six girlfriend's initials.

(Yes, even though Kelly appears four times in the last array, the K still counts as four elements. Not all the elements in an array have to be different.)

Here's something weird:

Zero: The first element in an array is numbered zero. Normally, if C were the least bit normal, the first element would be one. After all, all humans begin counting things as "One, two, three. . . ." Because C has to be different, though, the first element is zero.

  • C says, "Zero, one, two. . . ." Get used to it.
  • Please don't run away screaming just yet.
  • Arrays contain all the same type of variable: all integers, all characters, all floats -- all the same.
  • Each item in an array is an element.
  • Not every element has to be different. You can have an array of 52 items that are all the number 12, and it's still an array.
  • The first item in an array is number zero. This requirement is very weird and will toss you for a loop more than once during your C programming career.
  • Quite a few things in your PC begin numbering at zero. For example, the first memory address in your computer is address zero (written as 0x00000). The first argument typed at the DOS prompt is referred to as argv[0], which is also an array, as described in Lesson 6-3 in C For Dummies®, Volume I. Also gander at the PRINTME1.C program in Lesson 8-4. See how the first printer port in your PC (called LPT1) is really zero, or 0x00? LPT2, the second printer port, is value 0x01. See? I'm not making this stuff up either.

The element zero deal (which you don't have to read)

This element zero thing can drive you nuts, but don't let it. For example, the first jock in line has 16 on his jersey. That's element zero of the array. Here's how you could type that up in a nerdy C language-like way, assuming that the array is named jock_array and the element numbers are in square brackets:

jock_array[0] = 16;

jock_array[1] = 88;

jock_array[2] = 45;

jock_array[3] = 99;

jock_array[4] = 6;

jock_array[5] = 33;

Although this stuff may look complex, it's just a way to write down how each of the jock's jersey numbers would fit into an array. The zeroth (yes, that's a real word) element is 16; then 88, 45, 99, and 6; finally, the fifth element is 33. Though 33 is the sixth item in the array, in weirdo C it's referenced as item 5.

A simple program before you get too bored

An array can hold any series of numbers, such as the numbers in a safe's combination. The following program, SAFE.C, is the same program the manager at my local bank uses to remind herself how to open the Big Safe. (I'm reprinting this program with her permission; as long as you don't know that it's the Bank of America on First Street, she said that it would be okay.)

Carefully type this source code into your editor. The integer array, which is discussed in the following sections, is the only new item in there. For now, just type carefully, and you'll be okay:

Name: SAFE.C

#include <stdio.h>

void main()
{


    int numbers[] = { 36, 24, 12 };

    printf("The combination for the safe: ");
    printf("1. Turn to %i left. ",numbers[0]);
    printf("2. Turn to %i right. ",numbers[1]);
    printf("3. Turn to %i left, open. ",numbers[2]);


}

Compile and run. Here's what you should see:

The combination for the safe:
1. Turn to 36 left.
2. Turn to 24 right.
3. Turn to 12 left, open.

The array stored the three numbers, and then various printf statements reached into the array to grab the numbers back out.

  • Like any other variable, an array must be declared before you can use it. This subject is covered in the very next section.
  • Arrays are declared with the same words as any other variable: int for integer arrays, float for floating-point number arrays, and so on.
  • Square brackets are big in Array Land.
  • Elements in an array are referred to by the array name and then the element number. This subject is covered later in this lesson, in the section "Referring to elements in an array."

Properly declaring arrays in C

Like everything else in C, you can't pluck an array from thin air. No, as with other types of variables, you must declare it and type it in a proper and cryptic manner along with any other variables you plan to use in your program.

An array in C can be declared in two ways, depending on whether the array is empty or full.

A full array is one that already has information in it, like the numbers array in the SAFE.C program. It's defined like this:

int jock_array[] = {16, 88, 45, 99, 6, 33};

Table 9-1 tells you how each item fits into the big picture. Basically, there are three things: the type of array, int (integer); the array name, jock_array; and the values assigned to that array. The whole thing ends with a semicolon, just as any variable declaration does.

Table 9-1 Items You Need for a Full (Initialized) Array

Cryptogram

What It Does

int

Defines it as an array of integers

jock_array[]

The name of the array (square brackets are required and should be empty); the compiler figures out the array's size for you

=

Says "Set the contents of the array equal to the following values"

{

Curly brackets contain the array's info

16, 88, 45, 99, 6, 33

Numbers, separated by commas, to put into the array

}

Final curly bracket

;

Semicolon at the end of the variable declaration

The other type of array in C is empty, one you create to be filled in later. It's defined this way:

float coworker_IQ[20];

Rather than have numbers or other data assigned to this array, it merely has a size specified; 20 elements, in this example. It means that the coworker_IQ array has room for as many as 20 floating-point numbers.

The following check marks should answer most of the questions buzzing around in your head right now:

  • In both cases, the array is declared similarly to any other variable. First comes the variable type and then the variable name. The first array in the preceding example is an integer array named jock_array. The second array is a float array named coworker_IQ.
  • A full array is also referred to as an initialized array. It means that all the data -- each element in the array -- is already there.
  • An empty array is referred to as an uninitialized array.
  • For an initialized array, the values in the array are listed when the array is defined -- just as you can define any variable with a preset value, as explained in Lesson 3-3 in Volume I. Each element appears in curly brackets separated by a comma.
  • Love them curly brackets.
  • Commas appear after each number in the array, except for the last one. You will forget this statement often, and the compiler may or may not warn you, but your program will definitely screw up.
  • The last item in the array does not have a comma by it.
  • As always, a variable declaration must end in a semicolon, no matter which type of array you define.
  • For an uninitialized (or empty) array, you simply state how many elements you want in the square brackets. In the preceding example, the number of elements in the coworker_IQ array is set equal to 20; that array can have as many as 20 elements in it.
  • Technically speaking, when you declare an array like this:
  • int chairs[12];

    you're telling the compiler to set aside space for an array that contains 12 elements of integer number size. It's the same as though you were throwing a dinner party and invited 12 people -- you would need a long table with 12 chairs. (And then pray that no more than 12 people show up and each of them needs only one chair on which to sit.)

  • No, you cannot readily change an array's size; you must set the value when you write the program and hope that you set it big enough. This challenge is something C programmers wrestle with every day.
  • The square brackets are empty when you declare an initialized array. Fortunately, the compiler is smart enough to figure out the array's size and set it for you automatically. In the following declaration:
  • char cards[] = {'A', 'J', 'Q', 'K'};

    the compiler creates a single-character array named cards that can hold four elements. Then the characters A, J, Q, and K are stuffed into the array.

Referring to elements in an array

Each element in an array is its own variable. It has to be. Otherwise, you would never be able to pluck out any individual item in the array, and then, well, what would be the point?

To refer to any item in an array, you have to know the array's name and the element's number. The array's name is like any other variable name in C. The element number, however, is weird because the first element is zero, not one. When you know those two things, you just write down the array name, stick the element number between the square brackets, and -- presto! -- you have a variable just like any other.

In the SAFE.C program, for example, the first item in the array is referred to as numbers[0]. Even though a funky square bracket is in there, the compiler sees the thing as a single integer variable.

  • You can use array items throughout your program just as you would use any variable.
  • Assign a value to an array element just as you would assign any variable:

    orbit[1] = 53.449;

    or

    election[2000] = 78123;

    or

    input[7] = getch();

  • Even the element number can be a variable:

    loop[x] = counter();

    Here, variable x is used to indicate an element in the loop array, an element that has the value returned by the counter function.

Sticking stuff into an array (initializing it)

Here's a truly meaningless program for you. It creates an empty (uninitialized) array that can hold 20 elements (numbered 0 through 19, natch). Then the program fills those elements with the numbers 1 through 20, then 20 through 1, and then random numbers.

Carefully type this program into your editor. It uses the random-number-generation routines from the program RANDOM4.C in Lesson 5-7 in Volume I. You can cut and paste that chunk of text (the rnd and seedrnd functions). Although the source code seems rather long, it's really the same for loop repeated three times. Cut and paste!

Name: HURRAY.C


#include <stdio.h>
#include <stdlib.h>
#include <time.h> //for seeding randomizer

#define ELEMENTS 20

int rnd(int range);
void seedrnd(void);

void main()


{
int blorf[ELEMENTS];
int x;

/* First pass, fill array with values 1 through 20 */

printf("Initialize array from 1 to 20: ");
for(x=0;x<ELEMENTS;x++)
{
blorf[x] = x+1;
printf("%i\x20",blorf[x]);
}

/* Second pass, fill array with values 20 through 1 */

printf(" And now from 20 to 1: ");
for(x=0;x<ELEMENTS;x++)
{
blorf[x] = 20-x;
printf("%i\x20",blorf[x]);
}

/* Final pass, fill array with random values */

printf(" And now random numbers: ");
for(x=0;x<ELEMENTS;x++)
{
blorf[x] = rnd(20)+1;
printf("%i\x20",blorf[x]);
}
}

int rnd(int range)

{
int r;
r=rand()%range; //spit up random number
return(r);
}

void seedrnd(void)

{
srand((unsigned)time(NULL));
}

Double-check your work. An error is bound to be in there somewhere -- a missing semicolon or comment character.

Compile and run.

Here's the result:

Initialize array from 1 to 20:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
And now from 20 to 1:
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
And now random numbers:
7 11 3 11 17 18 16 16 9 7 5 19 12 20 13 1 13 2 4 8

Soothing words for the harried HURRAY.C program

Like most long programs, the HURRAY.C program contains a great deal of repetition. The idea is to fill the array and then display the results. Normally, your program might fill an array only once, either by itself or with user input. The array's contents may change, but probably not as shown in HURRAY.C.

The stdlib.h and time.h header files are included for the rnd and seedrnd functions, which are covered in Lesson 5-7 in Volume I. Notice that those functions are properly prototyped; refer to Lesson 5-1.

The define directive is used to set the size of the array, by assigning the shortcut word ELEMENTS to that value:

#define ELEMENTS 20

This shortcut is used throughout the program to represent the array's size. Oh, you could use the value directly, but by using the define directive, you can globally change the array size without having to go out and hunt down those references in the program's every nook and cranny.

The following line creates an array of integers named blorf (the array is named "blorf," not the integers). The array can hold 20 elements, as indicated by the ELEMENTS shortcut word:

int blorf[ELEMENTS];

The for loop repeats 20 times, raising the value of variable x from 0 to 19, which just also happens to be the way the elements are numbered in the array:

for(x=0;x<ELEMENTS;x++)

(See? Element zero does come in handy.)

Element x in the array is given the value of variable x plus one:

blorf[x] = x+1;

If x equals 0 (as it would the first time through the for loop), for example, element 0 of the array equals the value 1. Notice that the value of x is not incremented here. Incrementing x happens in the for loop. To display values 1 through 20, you must add 1 to the value of x. (Incrementing x is written as either x = x + 1 or x++.)

The printf statement displays element x's value for the blorf array:

printf("%i\x20",blorf[x]);

The value is displayed followed by the space character, \x20. Again, I do this because "%i " printed in a book doesn't make it clear whether a space follows the little i.

The second for loop reinitializes the array almost identically to the first for loop. The exception is the value assigned; it's 20-x, which puts values 20 through 1 into the array (the variable x loops from 0 through 19; 20 minus 0 is 1; 20 minus 1 is 19; and so on):


for(x=0;x<ELEMENTS;x++)
{
blorf[x] = 20-x;
printf("%i\x20",blorf[x]);
}

In the final for loop, random values from 1 through 20 are stuffed into the blorf array:

blorf[x] = rnd(20)+1;

Again, refer to Lesson 5-7 for details about the rnd(20)+1 construction.

The array named blorf is filled with three different sets of numbers, each of which can be changed like any other variable. See the previous sidebar, "Soothing words for the harried HURRAY.C program," for more detailed information about what's going on.

  • Values can also be placed into an array by reading the information from the keyboard. You can use the scanf or gets functions for that; refer to Lesson 3-1 in Volume I for information about reading numerical values from the keyboard.
  • Use gets to read information from the keyboard. More and more, I'm growing to hate the scanf function.
  • Keep in mind that values read in from the keyboard must match the type of variable the array holds: ints for integer arrays, floats for floating-point arrays, and so on.
  • The #define directive in this program sets the size of the blorf array to 20 elements. That's done so that the array size can be adjusted easily by editing that one line. Refer to Lesson 3-4 in Volume I for information about how handy the #define directive can be.
  • The \x20 escape sequence in the various printf statements inserts a blank (a space) between the array numbers. Refer to Table 2-1 in Volume I for more information about escape sequences.

An old but useful chestnut

The following program is a lottery-number picker, which is listed at the end of Volume I. Now that you're familiarizing yourself with arrays, the program should make a little more sense to you. It's listed next, minus the extensive comments from Volume I so that you can peruse the array aspects of the program:

Name: LOTTO.C

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //for the seedrnd() function

#define RANGE 50 //number of numbers
#define BALLS 6 //number of balls to draw
#define DELAY 1000000 //delay interval between picks

int rnd(int range);
void seedrnd(void);

void main()

{
int numbers[RANGE]; //array that holds the balls
int i,b;
unsigned long d; //delay variable
printf("L O T T O P I C K E R ");
seedrnd(); //seed the randomizer

/* initialize the array */

for(i=0;i<RANGE;i++) //initialize the array
numbers[i]=0;
printf("Press Enter to pick this week's numbers:");
getchar();

/* draw the numbers */

printf(" Here they come: ");
for(i=0;i<BALLS;i++)
{
for(d=0;d<=DELAY;d++); //pause here
/* picks a random number and check to see whether it's already been picked */
do
{
b=rnd(RANGE); //draw number
}
while(numbers[b]); //already drawn?
numbers[b]=1; //mark it as drawn
printf("%i ",b+1); //add one for zero
}
printf(" Good luck in the drawing! ");
}

/* Generate a random value */

int rnd(int range)

{
int r;
r=rand()%range; //spit up random number
return(r);
}

/* Seed the randomizer */

void seedrnd(void)

{
srand((unsigned)time(NULL));
}

Enter this source code into your editor (if you haven't already done so from Volume I). Compile and run.

L O T T O P I C K E R

Press Enter to pick this week's numbers:

Press the Enter key.

Here they come: 35 11 49 34 26 37

Good luck in the drawing!

The program picks six numbers from 1 to 50 as your lucky lotto numbers this week. (You can change the range of numbers by entering a new value for the RANGE define, and you can choose more or fewer numbers by changing the BALLS define, both at the beginning of the source code.)

This lotto program works the same way any computer card game works. Like cards in a deck, balls in a lottery machine can be drawn only once. The object is not to generate the same random number twice. That is, you can't draw the same lotto ball, bingo ball, or card from a deck in the real world, so you shouldn't be able to do that in a computer program either.

The solution is to keep track of the numbers (cards or whatever) drawn by using an array. The array is initialized with all zeros to start, which is done in Lines 23 and 24 in LOTTO.C:

for(i=0;i<RANGE;i++) //initialize the array

numbers[i]=0;

Then, as the random numbers are drawn, a one is inserted into the array to indicate which numbers (cards, whatever) have already been used. The following snippet makes that happen:

do
{
b=rnd(RANGE); //draw number
}
while(numbers[b]); //already drawn?

numbers[b]=1; //mark it as drawn
printf("%i ",b+1); //add one for zero

The variable b holds the number drawn, using the rnd() function introduced in Lesson 5-7 in Volume I. The rnd() function returns a value representing an element in the array. The do-while loop checks to see whether that value is equal to one -- which is TRUE -- if so, it keeps looping, generating new random numbers and checking the array for a zero or a one.

If the random number returned hasn't yet been drawn, the program continues; first, the value one (TRUE) is placed into the array with the numbers[b]=1; statement. That marks that number as "used." Then the number drawn is displayed on-screen. Note that the number displayed is b+1. That's because the rnd() function returns a value from zero through "RANGE." That's okay for filling the array, which also begins at element zero, but normally there's no zero ball in a lottery game.

The loop continues until the number of balls (represented by the shortcut word BALLS) has been drawn.

  • All this nonsense is created to ensure that the same number isn't drawn twice. By sticking a 1 into the array, you ensure that that number isn't drawn again in your program.
  • You could modify the LOTTO.C program to draw all 50 balls; just change the value of BALLS to 50 in the define statement. Notice that the program takes longer and longer to display the last few numbers as it waits for the random-number generator to produce a number that hasn't yet been drawn.
  • Now you can write that card game! You need an array of 52 elements, each of which represents a card in the deck. You can use a do-while loop similar to the one in LOTTO.C to determine which cards have already been drawn.
  • I could have initialized the array with values other than zero, and I could have used a value other than one to show that a ball had been drawn. In C, however, the values zero and one are typically used to represent FALSE and TRUE conditions, respectively. For more info, refer to Lessons 7-2 and 7-3 in Volume I.
  • I've been called on this before. The value 1 is not really equal to TRUE in C. Any nonzero value could be taken to equal 1. This is a minor quibble, raised primarily by minor quibblers.

Lesson 9-1 Quiz

1. The first element in an array is
A. The best element.
B. Element numero uno.
C. Element number one.
D. The zeroth element.

2. Zeroth is a real word:
A. TRUE.
B. FALSE.

3. What can be said about the following? int high_scores[] = { 99, 98, 99, 97};
A. It's an integer array.
B. The array has four elements.
C. The array is named high_scores.
D. Patrice Dabrowski was absent, so there is no 100 score.
E. All of the above.

4. Which of the following statements defines a floating-point array that contains three elements?
A. float ice_cream[3];
B. float buoy[] = {1.0794, 33.0, 1678.5};
C. float point[3] = { 1, 2, 3};
D. float root_beer[2];

5. What was the name of Paul Bunyan's ox?
A. Blue.
B. Babe.
C. Big Ox.
D. Bovus.
Read More Show Less

Customer Reviews

Average Rating 2
( 2 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(2)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 6 Customer Reviews
  • Anonymous

    Posted July 27, 2005

    not for linux

    It's a good starting out book on C,but the lessons don't compile in linux.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted June 25, 2003

    Great, but some details left out.

    C For Dummies Volume 1&2 is a great way for a beginner to learn the basics, concepts, and syntax of C. While I was reading this I often times switched between 'The C Programming Language' and this book, and this book is so much clearer then K&R2. This book by no means will make you expert in C, your very far from that after readin this. It will however give you the understanding of the concepts, basics, and syntax, much sooner. I recomend reading 'The C Programming Language' after reading this, as you will no doubtly get the context much easier after this. I also recomend 'The C Programming Language' it because of the standard library and refrence manual in the back. These two books will make you ready to take on some larger projects, and possibly pick up some intermediate C programming books. The downside of this book: Many concepts taught are frowned on my expirience C programmers. Many concepts are also left out. I think this book is best to build a basic knowledge, then you can read 'The C Programming Language.' Truly those two books couple together are a great read. I'm hoping that Dan Gookin makes a 3rd volume, possible with the missing chapter and supplmental lessons included.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted March 20, 2001

    C for dummies I, II

    I think that this was one of the best books that I have ever read on programming languages. I think that if you want to learn C, you should first learn a little bit of any basic language.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted April 30, 2001

    Incredible...Good for Beginners

    The book is great if you know pretty much nothing about the 'C' language. Dan Gookin does ramble on a lot, and the end-of-the-lesson quiz as well as end-of-the-chapter final exam will certainly keep you on your toes. Recommended for newbies. It is kind of boring but in the end, it does what is supposed to.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 16, 2001

    It's good

    C For Dummies volume one and two helped me learn and master the C language more quickly than any other book about programming languages I have ever read. I reccomend it to anyone. :)

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted September 13, 2010

    No text was provided for this review.

Sort by: Showing all of 6 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)