EssentialC资源-CSDN文库

4星 · 超过85%的资源需积分: 10 74 浏览量 2008-02-19 21:10:45 上传评论收藏 85KB PDF 举报

### Essential C：Stanford CS Education Library Summary #### Introduction "Essential C," authored by Nick Parlante and published as part of the Stanford CS Education Library, offers a concise yet comprehensive overview of the C programming language. This document is particularly valuable for individuals with some prior programming experience looking to understand or refresh their knowledge of C. The guide covers a wide range of topics, including basic data types, operators, control structures, complex data types, functions, and advanced concepts such as pointers and heap memory management. #### Basic Types and Operators In this section, "Essential C" delves into the fundamental data types and operators in C. It explains the various integer types, such as `int`, `short`, and `long`, along with floating-point types like `float` and `double`. The document highlights the importance of understanding type promotion and truncation, which occur when performing operations between different data types. For instance, an operation involving an `int` and a `double` will result in a `double` due to promotion rules. The section also covers assignment, comparison, and arithmetic operators. These include the basic mathematical operations (`+`, `-`, `*`, `/`), as well as compound assignment operators like `+=` and `-=`. Understanding these operators is crucial for manipulating values and performing calculations in C programs. #### Control Structures Control structures are essential for managing program flow. "Essential C" outlines several control structures, including: - **If Statement**: Used for conditional execution based on a boolean expression. - **Conditional Operator** (`?:`): A ternary operator that can be used as a shorthand for simple if-else statements. - **Switch Statement**: Allows for multiple conditions to be checked against a single variable. - **While Loop**: Executes a block of code repeatedly while a condition is true. - **For Loop**: Similar to a while loop but with a more compact syntax for initializing, testing, and updating the loop variable. - **Do-While Loop**: Guarantees that the loop body will execute at least once before checking the condition. - **Break and Continue Statements**: Control the flow within loops. These constructs enable programmers to create complex logic and control the execution sequence of their programs effectively. #### Complex Data Types The document also explores more advanced data types and constructs: - **Structs**: User-defined composite data types that allow grouping related data items. - **Arrays**: Fixed-size collections of elements of the same type. - **Pointers**: Variables that store memory addresses, enabling dynamic memory allocation and manipulation. - **Strings**: Special cases of character arrays used for text representation. Understanding how to use structs, arrays, and pointers is critical for creating efficient and scalable programs. The guide also covers the `typedef` keyword, which simplifies complex data types by assigning them more readable names. #### Functions Functions are central to modular programming in C. "Essential C" discusses the following aspects: - **Function Declaration and Definition**: How to define and call functions. - **Void Functions**: Functions that do not return a value. - **Value Parameters**: Passing arguments by value, where a copy of the argument is made. - **Reference Parameters**: Passing arguments by reference, allowing functions to modify the original variable directly. - **Const Qualifier**: Specifying that a parameter should not be modified within the function. Functions are essential for breaking down large programs into smaller, manageable pieces and for reusing code. #### Odds and Ends This section includes miscellaneous topics that are important for C programming: - **Main Function**: The entry point of every C program. - **Header and Source Files**: The `.h` and `.c` files convention for organizing code and declarations. - **Preprocessor**: A tool that processes source code before actual compilation, handling macros and includes. - **Assert Function**: A debugging tool for ensuring that certain conditions are met during runtime. #### Advanced Arrays and Pointers "Essential C" also delves into more advanced topics: - **Array and Pointer Interaction**: Explaining how arrays and pointers are related and how they interact. - **Base Address and Offset Arithmetic**: Techniques for accessing array elements using pointers. - **Heap Memory Management**: Allocating and deallocating memory dynamically using functions like `malloc` and `free`. - **Heap Arrays**: Creating arrays on the heap rather than the stack for more flexible memory usage. Understanding these concepts is vital for optimizing performance and managing resources efficiently. #### Operators and Standard Library Reference Finally, the document provides a reference guide covering common operators and standard library functions. This section serves as a handy resource for quick lookups and reminders. In conclusion, "Essential C" by Nick Parlante is a valuable resource for anyone interested in learning or revisiting the fundamentals of the C programming language. Its comprehensive coverage of key topics makes it suitable for both beginners and experienced programmers seeking to deepen their understanding of C.

资源推荐

资源详情

资源评论

Essential C

This Stanford CS Education document tries to summarize all the basic features of the C

language. The coverage is pretty quick, so it is most appropriate as review or for someone

with some programming background in another language. Topics include variables, int

types, floating point types, promotion, truncation, operators, control structures (if, while,

for), functions, value parameters, reference parameters, structs, pointers, arrays, the pre-

processor, and the standard C library functions.

The most recent version is always maintained at its Stanford CS Education Library URL

http://cslibrary.stanford.edu/101/. Please send your comments to

nick.parlante@cs.stanford.edu.

I hope you can share and enjoy this document in the spirit of goodwill in which it is given

away -- Nick Parlante, 4/2003, Stanford California.

Stanford CS Education Library This is document #101, Essential C, in the Stanford

CS Education Library. This and other educational materials are available for free at

http://cslibrary.stanford.edu/. This article is free to be used, reproduced, excerpted,

retransmitted, or sold so long as this notice is clearly reproduced at its beginning.

Table of Contents

Introduction .........................................................................................pg. 2

Where C came from, what is it like, what other resources might you look at.

Section 1 Basic Types and Operators ..........................................pg. 3

Integer types, floating point types, assignment operator, comparison operators,

arithmetic operators, truncation, promotion.

Section 2 Control Structures ........................................................pg. 11

If statement, conditional operator, switch, while, for, do-while, break, continue.

Section 3 Complex Data Types.....................................................pg. 15

Structs, arrays, pointers, ampersand operator (&), NULL, C strings, typedef.

Section 4 Functions........................................................................pg. 24

Functions, void, value and reference parameters, const.

Section 5 Odds and Ends ..............................................................pg. 29

Main(), the .h/.c file convention, pre-processor, assert.

Section 6 Advanced Arrays and Pointers....................................pg. 33

How arrays and pointers interact. The [ ] and + operators with pointers, base

address/offset arithmetic, heap memory management, heap arrays.

Section 7 Operators and Standard Library Reference ..............pg. 41

A summary reference of the most common operators and library functions.

The C Language

C is a professional programmer's language. It was designed to get in one's way as little as

possible. Kernighan and Ritchie wrote the original language definition in their book, The

C Programming Language (below), as part of their research at AT&T. Unix and C++

emerged from the same labs. For several years I used AT&T as my long distance carrier

in appreciation of all that CS research, but hearing "thank you for using AT&T" for the

millionth time has used up that good will.

Some languages are forgiving. The programmer needs only a basic sense of how things

work. Errors in the code are flagged by the compile-time or run-time system, and the

programmer can muddle through and eventually fix things up to work correctly. The C

language is not like that.

The C programming model is that the programmer knows exactly what they want to do

and how to use the language constructs to achieve that goal. The language lets the expert

programmer express what they want in the minimum time by staying out of their way.

C is "simple" in that the number of components in the language is small-- If two language

features accomplish more-or-less the same thing, C will include only one. C's syntax is

terse and the language does not restrict what is "allowed" -- the programmer can pretty

much do whatever they want.

C's type system and error checks exist only at compile-time. The compiled code runs in a

stripped down run-time model with no safety checks for bad type casts, bad array indices,

or bad pointers. There is no garbage collector to manage memory. Instead the

programmer mangages heap memory manually. All this makes C fast but fragile.

Analysis -- Where C Fits

Because of the above features, C is hard for beginners. A feature can work fine in one

context, but crash in another. The programmer needs to understand how the features work

and use them correctly. On the other hand, the number of features is pretty small.

Like most programmers, I have had some moments of real loathing for the C language. It

can be irritatingly obedient -- you type something incorrectly, and it has a way of

compiling fine and just doing something you don't expect at run-time. However, as I have

become a more experienced C programmer, I have grown to appreciate C's straight-to-the

point style. I have learned not to fall into its little traps, and I appreciate its simplicity.

Perhaps the best advice is just to be careful. Don't type things in you don't understand.

Debugging takes too much time. Have a mental picture (or a real drawing) of how your C

code is using memory. That's good advice in any language, but in C it's critical.

Perl and Java are more "portable" than C (you can run them on different computers

without a recompile). Java and C++ are more structured than C. Structure is useful for

large projects. C works best for small projects where performance is important and the

progammers have the time and skill to make it work in C. In any case, C is a very popular

and influential language. This is mainly because of C's clean (if minimal) style, it's lack

of annoying or regrettable constructs, and the relative ease of writing a C compiler.

Other Resources

• The C Programming Language, 2nd ed., by Kernighan and Ritchie. The thin book

which for years was the bible for all C programmers. Written by the original

designers of the language. The explanations are pretty short, so this book is better as a

reference than for beginners.

• http://cslibrary.stanford.edu/102/ Pointers and Memory -- Much more detail

about local memory, pointers, reference parameters, and heap memory than in this

article, and memory is really the hardest part of C and C++.

• http://cslibrary.stanford.edu//103/ Linked List Basics -- Once you understand the

basics of pointers and C, these problems are a good way to get more practice.

Section 1

Basic Types and Operators

C provides a standard, minimal set of basic data types. Sometimes these are called

"primitive" types. More complex data structures can be built up from these basic types.

Integer Types

The "integral" types in C form a family of integer types. They all behave like integers and

can be mixed together and used in similar ways. The differences are due to the different

number of bits ("widths") used to implement each type -- the wider types can store a

greater ranges of values.

char ASCII character -- at least 8 bits. Pronounced "car". As a practical matter

char is basically always a byte which is 8 bits which is enough to store a single

ASCII character. 8 bits provides a signed range of -128..127 or an unsigned range is

0..255. char is also required to be the "smallest addressable unit" for the machine --

each byte in memory has its own address.

short Small integer -- at least 16 bits which provides a signed range of

-32768..32767. Typical size is 16 bits. Not used so much.

int Default integer -- at least 16 bits, with 32 bits being typical. Defined to be

the "most comfortable" size for the computer. If you do not really care about the

range for an integer variable, declare it int since that is likely to be an appropriate

size (16 or 32 bit) which works well for that machine.

long Large integer -- at least 32 bits. Typical size is 32 bits which gives a signed

range of about -2 billion ..+2 billion. Some compilers support "long long" for 64 bit

ints.

The integer types can be preceded by the qualifier unsigned which disallows

representing negative numbers, but doubles the largest positive number representable. For

example, a 16 bit implementation of short can store numbers in the range

-32768..32767, while unsigned short can store 0..65535. You can think of pointers

as being a form of unsigned long on a machine with 4 byte pointers. In my opinion,

it's best to avoid using unsigned unless you really need to. It tends to cause more

misunderstandings and problems than it is worth.

Extra: Portability Problems

Instead of defining the exact sizes of the integer types, C defines lower bounds. This

makes it easier to implement C compilers on a wide range of hardware. Unfortunately it

occasionally leads to bugs where a program runs differently on a 16-bit-int machine than

it runs on a 32-bit-int machine. In particular, if you are designing a function that will be

implemented on several different machines, it is a good idea to use typedefs to set up

types like Int32 for 32 bit int and Int16 for 16 bit int. That way you can prototype a

function Foo(Int32) and be confident that the typedefs for each machine will be set so

that the function really takes exactly a 32 bit int. That way the code will behave the same

on all the different machines.

char Constants

A char constant is written with single quotes (') like 'A' or 'z'. The char constant 'A' is

really just a synonym for the ordinary integer value 65 which is the ASCII value for

uppercase 'A'. There are special case char constants, such as '\t' for tab, for characters

which are not convenient to type on a keyboard.

'A' uppercase 'A' character

'\n' newline character

'\t' tab character

'\0' the "null" character -- integer value 0 (different from the char digit '0')

'\012' the character with value 12 in octal, which is decimal 10

int Constants

Numbers in the source code such as 234 default to type int. They may be followed by

an 'L' (upper or lower case) to designate that the constant should be a long such as 42L.

An integer constant can be written with a leading 0x to indicate that it is expressed in

hexadecimal -- 0x10 is way of expressing the number 16. Similarly, a constant may be

written in octal by preceding it with "0" -- 012 is a way of expressing the number 10.

Type Combination and Promotion

The integral types may be mixed together in arithmetic expressions since they are all

basically just integers with variation in their width. For example, char and int can be

combined in arithmetic expressions such as ('b' + 5). How does the compiler deal

with the different widths present in such an expression? In such a case, the compiler

"promotes" the smaller type (char) to be the same size as the larger type (int) before

combining the values. Promotions are determined at compile time based purely on the

types of the values in the expressions. Promotions do not lose information -- they always

convert from a type to compatible, larger type to avoid losing information.

Pitfall -- int Overflow

I once had a piece of code which tried to compute the number of bytes in a buffer with

the expression (k * 1024) where k was an int representing the number of kilobytes

I wanted. Unfortunately this was on a machine where int happened to be 16 bits. Since

k and 1024 were both int, there was no promotion. For values of k >= 32, the product

was too big to fit in the 16 bit int resulting in an overflow. The compiler can do

whatever it wants in overflow situations -- typically the high order bits just vanish. One

way to fix the code was to rewrite it as (k * 1024L) -- the long constant forced the

promotion of the int. This was not a fun bug to track down -- the expression sure looked

reasonable in the source code. Only stepping past the key line in the debugger showed the

overflow problem. "Professional Programmer's Language." This example also

demonstrates the way that C only promotes based on the types in an expression. The

compiler does not consider the values 32 or 1024 to realize that the operation will

overflow (in general, the values don't exist until run time anyway). The compiler just

looks at the compile time types, int and int in this case, and thinks everything is fine.

Floating point Types

float Single precision floating point number typical size: 32 bits

double Double precision floating point number typical size: 64 bits

long double Possibly even bigger floating point number (somewhat obscure)

Constants in the source code such as 3.14 default to type double unless the are suffixed

with an 'f' (float) or 'l' (long double). Single precision equates to about 6 digits of

precision and double is about 15 digits of precision. Most C programs use double for

their computations. The main reason to use float is to save memory if many numbers

need to be stored. The main thing to remember about floating point numbers is that they

are inexact. For example, what is the value of the following double expression?

(1.0/3.0 + 1.0/3.0 + 1.0/3.0) // is this equal to 1.0 exactly?

The sum may or may not be 1.0 exactly, and it may vary from one type of machine to

another. For this reason, you should never compare floating numbers to eachother for

equality (==) -- use inequality (<) comparisons instead. Realize that a correct C program

run on different computers may produce slightly different outputs in the rightmost digits

of its floating point computations.

Comments

Comments in C are enclosed by slash/star pairs: /* .. comments .. */ which

may cross multiple lines. C++ introduced a form of comment started by two slashes and

extending to the end of the line: // comment until the line end

The // comment form is so handy that many C compilers now also support it, although it

is not technically part of the C language.

Along with well-chosen function names, comments are an important part of well written

code. Comments should not just repeat what the code says. Comments should describe

what the code accomplishes which is much more interesting than a translation of what

each statement does. Comments should also narrate what is tricky or non-obvious about a

section of code.

Variables

As in most languages, a variable declaration reserves and names an area in memory at run

time to hold a value of particular type. Syntactically, C puts the type first followed by the

name of the variable. The following declares an int variable named "num" and the 2nd

line stores the value 42 into num.

int num;

num = 42;

num 42

A variable corresponds to an area of memory which can store a value of the given type.

Making a drawing is an excellent way to think about the variables in a program. Draw

each variable as box with the current value inside the box. This may seem like a

"beginner" technique, but when I'm buried in some horribly complex programming

problem, I invariably resort to making a drawing to help think the problem through.

Variables, such as num, do not have their memory cleared or set in any way when they

are allocated at run time. Variables start with random values, and it is up to the program

to set them to something sensible before depending on their values.

Names in C are case sensitive so "x" and "X" refer to different variables. Names can

contain digits and underscores (_), but may not begin with a digit. Multiple variables can

be declared after the type by separating them with commas. C is a classical "compile

time" language -- the names of the variables, their types, and their implementations are all

flushed out by the compiler at compile time (as opposed to figuring such details out at run

time like an interpreter).

剩余44页未读，继续阅读

评论收藏

内容反馈

ToConnection

2013-07-18

不错，谢谢，英文版的
rgqclzz

2014-08-17

版面不是很好，不过貌似网上也找不到别样的了，好像都是这一版……

cdlinux

粉丝: 1
资源: 5

Essential C

EssentialC

Essential C.pdf

[Essential C（注释版）].斯坦利.扫描版

Essential C# 5.0

Essential C++中文版.pdf

Essential-PH1-WindowsDrivers

ph67-ud3-b3 DELL SLIC2.1的BIOS

安卓之父Essential Phone刷miui11.rar

Essential Windows Phone 7.5

安卓刷机驱动

Essential c

essential c

Essential_C%2B%2B中文版.pdf

EssentialCpp:Essential C ++的练习，作者是Stanley Lippman

Essential C#

Essential C++中文版+完整源代码+习题答案

Essential Windows Phone 7.5: Application Development with Silverlight

刷机驱动MT6572

手机刷机驱动包

Essential C++中文版

Essential Cpp Essential C++

gcc和build-essential离线安装deb包.zip

build-essential.7z

build-essential_11.3.tar.gz_ build-essenti_build-essentia_build-

Essential C++源代码

JBL Flip Essential用户配置说明书.pdf

Essential C++中文版pdf

Essential+C++中文版.pdf

Essential C++中文版.PDF stanley B. Lippman 侯捷 侯俊杰

最新资源

Essential C++中文版.PDF stanley B. Lippman 侯捷侯俊杰