21天掌握C语言：英文版经典教程

需积分: 10 9 浏览量更新于2024-07-28 收藏 2.84MB PDF 举报

"21天学习C语言英文版是经典的C语言教程，适合初学者入门，通过21天的系统学习，能帮助读者掌握C语言的基础和进阶知识。" 在《21 Days to Learn C》这本教程中，作者精心安排了21天的学习计划，覆盖了C语言的核心概念和技术。以下是对每个学习日主题的详细说明： 1. **Day1 - Getting Started with C**: 这一章介绍了C语言的历史和环境设置，包括编译器的安装与使用，以及编写和运行第一个C程序。 2. **Day2 - The Components of a C Program**: 讨论了C程序的基本结构，如预处理指令、函数定义、主函数、注释等。 3. **Day3 - Storing Data: Variables and Constants**: 阐述变量和常量的概念，包括数据类型、声明、初始化和作用域。 4. **Day4 - Statements, Expressions, and Operators**: 解析C语言中的语句、表达式和运算符，如赋值运算符、算术运算符、逻辑运算符等。 5. **Day5 - Functions: The Basics**: 介绍函数的使用，包括函数的定义、调用、参数传递以及函数返回值。 6. **Day6 - Basic Program Control**: 讲解流程控制，如条件语句（if-else）和循环语句（for, while, do-while）。 7. **Day7 - Fundamentals of Input and Output**: 讨论标准输入输出流，如printf和scanf函数，以及文件操作的基本概念。 8. **Day8 - Using Numeric Arrays**: 介绍数组的使用，包括一维数组、多维数组的操作及其在程序中的应用。 9. **Day9 - Understanding Pointers**: 深入理解指针，包括指针的声明、赋值、运算，以及指针和数组、函数的关系。 10. **Day10 - Characters and Strings**: 讲解字符和字符串处理，如字符数组、字符串常量、字符串函数（strcpy, strcat, strcmp等）。 11. **Day11 - Structures**: 介绍结构体，一种自定义数据类型，用于组合不同类型的数据。 12. **Day12 - Understanding Variable Scope**: 解释变量的作用域，包括局部变量、全局变量和静态变量。 13. **Day13 - Advanced Program Control**: 进一步讨论更复杂的流程控制，如嵌套循环、开关语句（switch-case）和递归。 14. **Day14 - Working with the Screen, Printer, and Keyboard**: 探讨直接与硬件交互的低级I/O操作，如屏幕打印和键盘输入。 15. **Day15 - Pointers: Beyond the Basics**: 进一步探讨指针的高级用法，如指针数组、指向指针的指针，以及动态内存分配。 16. **Day16 - Using Disk Files**: 学习文件操作，包括文件打开、读写、关闭以及文件指针的使用。 17. **Day17 - Manipulating Strings**: 更深入地研究字符串操作，包括字符串的复制、连接、比较和查找等。 18. **Day18 - Getting More from Functions**: 讨论函数的高级用法，如函数指针、递归函数和函数重载（在C++中）。 19. **Day19 - Exploring the C Function Library**: 介绍C标准库中的常见函数，如数学函数、内存管理函数等。 20. **Day20 - Working with Memory**: 解析动态内存管理，包括malloc, free, realloc等函数的使用。 21. **Day21 - Advanced Compiler Use**: 讨论编译器的高级特性，如编译选项、链接器命令和调试技巧。此外，附录提供了ASCII字符表、保留关键字列表、二进制和十六进制数字的工作方式、移植性问题、常用C函数参考、C++简介以及答案解析，为读者提供了额外的学习资源和参考。通过这21天的学习，读者将能够熟练掌握C语言的基础语法，理解指针和内存管理，并具备编写简单到中等复杂度C程序的能力。尽管是英文版，但坚持学习将会带来显著的进步和收获。

4. Verify that HELLO.C is on disk by listing the files in the directory or folder. You should see

HELLO.C within this listing.

5. Compile and link HELLO.C. Execute the appropriate command specified by your compiler's

manuals. You should get a message stating that there were no errors or warnings.

6. Check the compiler messages. If you receive no errors or warnings, everything should be okay.

If you made an error typing the program, the compiler will catch it and display an error message.

For example, if you misspelled the word printf as prntf, you would see a message similar to the

following:

Error: undefined symbols:_prntf in hello.c (hello.OBJ)

7. Go back to step 2 if this or any other error message is displayed. Open the HELLO.C file in

your editor. Compare your file's contents carefully with Listing 1.1, make any necessary

corrections, and continue with step 3.

8. Your first C program should now be compiled and ready to run. If you display a directory listing

of all files named HELLO (with any extension), you should see the following:

HELLO.C, the source code file you created with your editor

HELLO.OBJ or HELLO.O, which contains the object code for HELLO.C

HELLO.EXE, the executable program created when you compiled and linked HELLO.C

9. To execute, or run, HELLO.EXE, simply enter hello. The message Hello, World! is displayed

on-screen.

Congratulations! You have just entered, compiled, and run your first C program. Admittedly, HELLO.C

is a simple program that doesn't do anything useful, but it's a start. In fact, most of today's expert C

programmers started learning C in this same way--by compiling HELLO.C--so you're in good company.

Compilation Errors

A compilation error occurs when the compiler finds something in the source code that it can't compile. A

misspelling, typographical error, or any of a dozen other things can cause the compiler to choke.

Fortunately, modern compilers don't just choke; they tell you what they're choking on and where it is!

This makes it easier to find and correct errors in your source code.

This point can be illustrated by introducing a deliberate error into HELLO.C. If you worked through that

example (and you should have), you now have a copy of HELLO.C on your disk. Using your editor,

move the cursor to the end of the line containing the call to printf(), and erase the terminating semicolon.

HELLO.C should now look like Listing 1.2.

Listing 1.2. HELLO.C with an error.

1: #include <stdio.h>

3: main()

4: {

5: printf("Hello, World!")

6: return 0;

7: }

Next, save the file. You're now ready to compile it. Do so by entering the command for your compiler.

Because of the error you introduced, the compilation is not completed. Rather, the compiler displays a

message similar to the following:

hello.c(6) : Error: `;' expected

Looking at this line, you can see that it has three parts:

hello.c The name of the file where the error was found

(6) : The line number where the error was found

Error: `;' expected A description of the error

This message is quite informative, telling you that in line 6 of HELLO.C the compiler expected to find a

semicolon but didn't. However, you know that the semicolon was actually omitted from line 5, so there is

a discrepancy. You're faced with the puzzle of why the compiler reports an error in line 6 when, in fact, a

semicolon was omitted from line 5. The answer lies in the fact that C doesn't care about things like

breaks between lines. The semicolon that belongs after the printf() statement could have been placed on

the next line (although doing so would be bad programming practice). Only after encountering the next

command (return) in line 6 is the compiler sure that the semicolon is missing. Therefore, the compiler

reports that the error is in line 6.

This points out an undeniable fact about C compilers and error messages. Although the compiler is very

clever about detecting and localizing errors, it's no Einstein. Using your knowledge of the C language,

you must interpret the compiler's messages and determine the actual location of any errors that are

reported. They are often found on the line reported by the compiler, but if not, they are almost always on

the preceding line. You might have a bit of trouble finding errors at first, but you should soon get better

at it.

NOTE: The errors reported might differ depending on the compiler. In most cases, the error

message should give you an idea of what or where the problem is.

Before leaving this topic, let's look at another example of a compilation error. Load HELLO.C into your

editor again and make the following changes:

1. Replace the semicolon at the end of line 5.

2. Delete the double quotation mark just before the word Hello.

Save the file to disk and compile the program again. This time, the compiler should display error

messages similar to the following:

hello.c(5) : Error: undefined identifier `Hello'

hello.c(7) : Lexical error: unterminated string

Lexical error: unterminated string

Fatal error: premature end of source file

The first error message finds the error correctly, locating it in line 5 at the word Hello. The error message

undefined identifier means that the compiler doesn't know what to make of the word Hello, because it is

no longer enclosed in quotes. However, what about the other four errors that are reported? These errors,

the meaning of which you don't need to worry about now, illustrate the fact that a single error in a C

program can sometimes cause multiple error messages.

The lesson to learn from all this is as follows: If the compiler reports multiple errors, and you can find

only one, go ahead and fix that error and recompile. You might find that your single correction is all

that's needed, and the program will compile without errors.

Linker Error Messages

Linker errors are relatively rare and usually result from misspelling the name of a C library function. In

this case, you get an Error: undefined symbols: error message, followed by the misspelled name

(preceded by an underscore). Once you correct the spelling, the problem should go away.

Summary

After reading this chapter, you should feel confident that selecting C as your programming language is a

wise choice. C offers an unparalleled combination of power, popularity, and portability. These factors,

together with C's close relationship to the C++ object-oriented language as well as Java, make C

unbeatable.

This chapter explained the various steps involved in writing a C program--the process known as program

development. You should have a clear grasp of the edit-compile-link-test cycle, as well as the tools to use

for each step.

Errors are an unavoidable part of program development. Your C compiler detects errors in your source

code and displays an error message, giving both the nature and the location of the error. Using this

information, you can edit your source code to correct the error. Remember, however, that the compiler

can't always accurately report the nature and location of an error. Sometimes you need to use your

knowledge of C to track down exactly what is causing a given error message.

Q&A

Q If I want to give someone a program I wrote, which files do I need to give him?

A One of the nice things about C is that it is a compiled language. This means that after the source

code is compiled, you have an executable program. This executable program is a stand-alone

program. If you wanted to give HELLO to all your friends with computers, you could. All you

need to give them is the executable program, HELLO.EXE. They don't need the source file,

HELLO.C, or the object file, HELLO.OBJ. They don't need to own a C compiler, either.

Q After I create an executable file, do I need to keep the source file (.C) or object file (.OBJ)?

A If you get rid of the source file, you have no way to make changes to the program in the future,

so you should keep this file. The object files are a different matter. There are reasons to keep

object files, but they are beyond the scope of what you're doing now. For now, you can get rid of

your object files once you have your executable file. If you need the object file, you can recompile

the source file.

Most integrated development environments create files in addition to the source file (.C), the

object file (.OBJ or .O), and the executable file. As long as you keep the source file (.C), you can

always recreate the other files.

Q If my compiler came with an editor, do I have to use it?

A Definitely not. You can use any editor, as long as it saves the source code in text format. If the

compiler came with an editor, you should try to use it. If you like a different editor better, use it. I

use an editor that I purchased separately, even though all my compilers have their own editors. The

editors that come with compilers are getting better. Some of them automatically format your C

code. Others color-code different parts of your source file to make it easier to find errors.

Q Can I ignore warning messages?

A Some warning messages don't affect how the program runs, and some do. If the compiler gives

you a warning message, it's a signal that something isn't right. Most compilers let you set the

warning level. By setting the warning level, you can get only the most serious warnings, or you

can get all the warnings, including the most minute. Some compilers even offer various levels

in-between. In your programs, you should look at each warning and make a determination. It's

always best to try to write all your programs with absolutely no warnings or errors. (With an error,

your compiler won't create the executable file.)

Workshop

The Workshop provides quiz questions to help you solidify your understanding of the material covered

and exercises to provide you with experience in using what you've learned. Try to understand the quiz

and exercise answers before continuing to the next chapter. Answers are provided in Appendix G,

"Answers."

Quiz

1. Give three reasons why C is the best choice of programming language.

2. What does the compiler do?

3. What are the steps in the program development cycle?

4. What command do you need to enter in order to compile a program called PROGRAM1.C with

your compiler?

5. Does your compiler do both the linking and compiling with just one command, or do you have

to enter separate commands?

6. What extension should you use for your C source files?

7. Is FILENAME.TXT a valid name for a C source file?

8. If you execute a program that you have compiled and it doesn't work as you expected, what

should you do?

9. What is machine language?

10. What does the linker do?

剩余530页未读，继续阅读

乘着叶片往前飞的蜗牛

粉丝: 0
资源: 4

21天掌握C语言：英文版经典教程

21天学会C语言

21天学好c语言

21天学会C编程语言

21天精通c语言

21天学会c语言

21天c语言学习PPT教程

21天学通C语言 完全版

21天学通C语言电子版

c语言课件 c21天学习 编程 详细的c语言

21天学会C语言_源代码

最新资源

21天学通C语言完全版

c语言课件 c21天学习编程详细的c语言