At noon, colleagues went out to eat.
I am going to go to Houjie's website to turn it on the website, and I have not been small. I will dig out an article to see: I will treat standard C as a new language Learning Standard C as a new language author Bjarne Stroustrup Translator Don't treat C as a latter language. This question asked the father of C . Houjie Note: This article is a Chinese Journal 2001/04. The translation is smooth and the technology is full. Mr. Chen Mr. Chen Mr. Chen, a person in charge of "Programmer" magazine, is reproduced here, thank you for Taiwan readers.
Mr. Chen, Mr. Chen and Mr. Jiang Tao did not reprint this article. ________________________________________ C / C User's Journal May, 1999Learning Standard C as a New Languageby Bjarne Stroustrup________________________________________ want to get import standard C [1 triple test data] of the biggest advantages we have to rethink the way of writing programs in C . One of the ways to rethink is that thinking about how C is learning (and education). What kind of programming technology should we emphasize? Which part of this language should we first learn? Which part we want in the real program code? This article compares several simple C programs, some of which have written in a modern style (using standard program library), and some are written in traditional C language style. The homework learned from these simple examples is still important to the big rules. Generally speaking, this article advocates the use of C as a higher-order language, which relies on abstraction and elegance, but does not lose efficiency under low order. We all want programs easy to write, properly executed, easy to maintain, and efficiency can be accepted. This means that we should use C (or any other language) in a closest way. I suspect that the C ethnic group has not been able to digest all kinds of facilities brought by standard C ; re-thinking that our way of use of C can obtain some important improvements and further achieve the above ideals. The programming style attached to this paper is to fully use standard C supported facilities, not in those facilities itself. The main improvement is to reduce the size and complexity of the code we have written through the application of the program library. Here I am in some simple example, demonstrate and quantify these reductions. This simple instance may appear in any C importability course. Due to the reduction of size and complexity, we reduce the development time, reducing maintenance costs, and reduces test costs. Another focus is that through the application of the transcript library, we can simplify C learning. This simplification should be quite abundant for small programs and students who have achieved good results. However, professional programs have extremely demanding efficiency, only in the case where efficiency is not sacrificed, we will expect themselves to improve programming style to meet the stringent needs of modern services and commerce in data and instant responses. To this end, I showed a measurement result, which proves that the reduction in complexity does not lose efficiency. Finally, I also discussed this view for the impact of learning and education C . Complexity tries to consider a topic, it is very suitable for the second practice for programming language courses (translation: The first exercise is of course "Hello World": Output a prompt "please enter your name" read name Output "Hello
COUT << "please enter your name: / n"; string name; cin >> name; cout << "hello" << name << '/ n';} To a real beginner, we must explain the entire architecture . What is main ()? What did #include did? What is USING? In addition, we have to understand all the tip rules, such as / N, where to add a semicolon ┅, etc. However, the main ingredients of this program, the concept is very simple, and the textual description of the topic is only different. We must learn this representation, that is very simple: String is a string (string), cout is an Output (output device), << is a operator we used to write to the output device to wait. For comparison, the following is a traditional C-Style solution [Note 1]: # include
// read the character into the Name scanf ("% s", name); Printf ("Hello% S / N", Name); return 0;} is obvious, the main logic has a slight - only slight ─ Change, complex than C - Style version, because we must explain the array and weird symbol% s. The main problem is that this simple c-style solution has no value. If someone enters a name of a length greater than 19 (so-called 19, it is reduced by the above specified 20, the 1 1 of the deduction is used to place the end of the C-style string), this program is finished. Some people think that this inferior quality does not cause harm, as long as it uses some appropriate solution to "later introduction". Even if this, the row of disputes is only "acceptable", but also does not reach "good" realm. Ideally we should not let a rookie user face an easy-to-machine program. How can this C-Style can be used like a C - Style program? First we can use Scanf to avoid array overflow: # include
INT min () {const Int max 20; char name [max]; Printf ("please enter you first name: / n"); scanf ("% 19s", name); // read up to 19 words PRINTF ("Hello% S / N", Name); Return 0;} Nothing standard methods can directly use the symbol type buffer size directly in the format string of Scanf, so I must use integer field constants as above. That is a poor style, also a non-time bomb when it is in the future. The following is an expert-level approach, but it is really difficult to reverse beginners: char FMT [10]; // Generate a format string, such as using simple% s may cause a sewage (overflow) Sprintf (FMT, "% %% DS ", MAX-1); // Read to MAX-1 font to Name. Scanf (FMT, Name); in addition, this program cuts the "exceeding the buffer size". However, we hope that the string can grow as input. In order to do this, we must drop the abstraction to a lower level, handle individual characters: #include
INT main () {int max = 20; // Configure buffer: char * name = (char *) malloc (max); if (name == 0) quit (); Printf ("please enter your first name: / n "); // Skip the predecessor's blank font while (true) {int C = getchar (); if (c = eof) Break; // File ends if (! isspace (c)) {UNGETC (C, STDIN); BREAK;}}
INT i = 0; while (True) {INT C = getchar (); if (c == '/ n' || c == EOF) {// At the end plus ending character 0 Name [i] = 0; Break;} name [i] = C; if (i == max-1) {// buffer fills MAX = Max max; name = (char *) Realloc (Name, Max); if ( Name == 0) quit ();} itt;}
Printf ("Hello% S / N", Name; Free (Name); // Release memory RETURN 0;} and the previous version compared, this version is significantly more complicated. Plus a "skipheading the predecessors" treatment, I feel some sin, because I didn't understand this demand in the title narrative. However, "Skiphead Guide Bills" is normal, and other versions will be done later. Some people may think that this example is not so bad. Most experienced C programs and C pristines may have written some things in real applications. We may even think that if you can't write such a program, you can't be a professional pristine. However, think about these things that are burdopless to beginners. The above program uses seven different C standard functions, and handles the input of the character level at a very trivial level, which uses the indicator, and handles free space (Free Store, the translation note: is usually HEAP). In order to use Realloc, I must use Malloc (not New). This is brought into the topic of size and type converting [Note 2]. In a small range, what is the best practices that deal with the problem of memory that may happen? The answer is not obvious. Here I am just doing something, eliminating this discussion of deteriorating as another unhappy topic. People who are used to use C-Style must thinkually think about which method can form a good foundation for a deeper teaching and final practical use. Summary, in order to solve the original simple problem, in addition to the problem core itself, I have to introduce the size, indicator, transformation, and freedom of freedom, explicit management. And this programming style is full of opportunities for errors. Thank you for your experience, I can avoid any significant size difference or an off-by-one or a memory configuration error. When I face Stream I / O, I made a typical beginner error at the beginning: read into a char (not an int) and forget to check EOF. At the age of C standard program, it is not surprising. Many teachers can't get rid of these things that are not worthless, temporarily put them later. Unfortunately, many students only pay attention to this bad style "good", which is written than its C Style brother. So they developed a habit of breaking and left a trajectory that is easy to make mistakes. The last C-Style has 41 lines, while the functional C - Style is only 10 lines. After deducting the basic architecture, the ratio is 30: 4. More importantly, the few lines of C - Style are not only shorter, and their essence is easier to understand. The number of rows and concept complexity of C - Style and C-Style are difficult to objectively measure, but I think C - Style has a 10: 1 advantage. Efficiency EffiCIENCY is not a topic for a number of unrelated pain such as the above-mentioned small example. Faced with this type of program, simplified and (type) security is the focus. However, the real system is often composed of some ingredients of efficiency.
For such systems, the problem becomes "Can we give higher order abstraction?" Consider this kind of empowerment, the following is a simple example: read into an unknown number of elements to do some of the elements Some movements do some of the simplest and clear examples of action involving all elements I can think of is that the average value of a series of double-precision floating point numbers from the input device is calculated in the program. The following is a traditional C-style solution: // c-style solution: #include Qsort (BUF, N, SIZEOF (DOUBLE), Compare; if (n) {int MID = N / 2; Median = (N% 2)? BUF [MID]: (BUF [MID-1] BUF [MID ]) / 2;} Printf ("NUMBER OF Elements =% D, Median =% G, Mean =% g / n", n, median, mean; free (buf);} The following is a common C solution: / / Use C standard program library solution: #include Main (int Argc, char * argv []) {char * file = argv [2]; vector Why do you have to give a number of elements? (Because the array doesn't know how many elements I have), why do you have to give a double size? (Because Qsort does not know that the unit it wants to sort is Doubles.) Why do you have to write that ugly, used to compare Doubles value? (Because Qsort needs an indicator to point to a function, because it doesn't know the element type it wants to be sorted, the comparison letter used by QSORT accepts const void * quotes instead of char * quotes? (Because Qsort can sort the numerical value of non-strings) Void * What does it mean? What does it mean in front of CONST? (Hey, let's talk about this topic later) explain these questions about beginners, I am afraid it is difficult to make them two eyes. Compared to explaining sort (v.begin (), v.end ()) is much easier: "Simple Sort (V) is relatively simple, but sometimes we want to sort some part of the container, So more general mode is to specify the range of sorting operations. In order to compare efficiency, I must first determine how much input can make efficiency. Due to 50,000 materials, it is not only used for half a second, so I chose to be more than 500,000 inputs and 5,000,000 inputs. The results are shown in Table 1. Table 1 / Read, Sort, Optimization Floating Point Optimization After optimization C C C / C ratio C C / C ratio 500,000 pens 3.5 6.1 1.74 2.5 5.1 2.045,000,000 Information 38.4 172.6 4.49 27.4 126.6 4.62 Key numbers are the ratio. The ratio is greater than 1 indicates that the C - Style version is faster. The comparison between language, program library, and programming style is well known, so please do not make a thorough conclusion according to these simple tests. These ratios are the average of several execution results on different machines. Different execution environments in the same program are less than 1 percentage. I also implemented my C-Style's ISO C strictly compatible version, as expected, there is no efficiency difference. I expect C - Style programs a little bit a little. After the C compiler of the inspection, I found that the implementation results have a surprising change. At some point, the C-Style version performs better than the C - Style version in the case of small information. However, the focus of this example is that we can face the currently known technique, providing a higher order abstraction and a better protection against errors. The C compiler I use is generally cheap-not toys in the study room. Those compilers claim to provide higher efficiency, of course, also apply to this result. To find some people, willing to pay 3, 10 or even 50 ratios on the convenience and preferred error, and it is not uncommon. But if you put these benefits, add twice or four times the speed, it is very spectacular and attractive. These numbers should be a minimum of a C program library vendor. In order to know how time spent, I have made some additional tests (see Table 2). Table 2 / Read the floating point number and sort. In order to understand the cost of the input action, I add a "generate" function to generate a random value. 500,000 data: Best pre-optimization C C C / C ratio C C C / C ratio read information read 2.8 1.33 2.0 2.8 1.4 Generate generate 0.6 0.3 0.5 0.4 0.3 0.75 Read and sort read & Sort 3.5 6.1 1.75 2.5 5.1 2.04 Generation and Sort Generate & Sort 2.0 3.5 1.75 0.9 2.6 2.895,000,000 Information: Best Pre-optimization After C C / C ratio C C / C ratio read information READ 21.5 29.1 1.35 21.3 28.6 1.34 Generate 7.2 4.1 0.57 5.2 3.6 0.69 Reading and sorting READ & SORT 38.4 172.6 4.62 Generation and Sort Generate & Sort 24.4 147.1 6.03 11.3 100.6 8. Of course, "Read" is just reading information, "Read & Sort "Just reading data and sorting, they do not produce any output. In order to get a better feeling of input cost, "generate" is used to generate a random value, not from the input device. In other examples and other compilers, I expect C stream I / O to be slightly slower than stdio. The previous version of this system uses CIN instead of File Stream, the situation is true. On some C compilers, the I / O files are really much more faster than CIN, and at least one of its reasons is due to the poor treatment between CIN and COUT. However, the above value is displayed, C - Style I / O can be efficient like C-Style I / O. If you change these programs, the objects they read and sorted are integer rather than floating point numbers, and they do not change relative efficiency - although we can surprise, this change is very simple to C - Style. Two changes, the C-Style requires 12 changes). This is a good sign for easy maintenance. The difference in the "Generate" test shows the cost of the configuration. A vector plus push_back should be as fast as an array plus malloc / free, but it is not the case. The reason is that it is difficult to remove the call action of the initial value setting column (INITIALIZERS) "in the optimization process. Fortunately, the cost of the configuration is almost always small in front of the cost that is initiated by the input (resulting in configuration requirements). As for SORT, as expected to be much faster than QSort, the main reason is that the comparison action in the sort is in-inlines, and QSort must call a form. It is really difficult to select an example that can be explained to the efficiency issue. The opinion I got from my colleagues is that reading and comparing "value" is not real enough, should be read into "string" and sort. So I wrote the following: #include INT main (int Argc, char * argv []) {char * file = argv [2]; // Enter the file name char * ofile = argv [3]; // Output file name Vector I am very horrified that my test program is twice as fast as C Style and C Style, but only half of the other in another system. If the change factors between the system exceed 4, the pristine should not accept it. As I can understand, this variability is not formed due to basic factors, so it is not necessary to have an exaggeration of exaggeration efforts in the authors of the program, should meet the efficiency consistency. The optimization program library may be the easiest way to improve the recognition and actual efficiency of standard C . Yes, the compiler actor works hard to eliminate the minor efficiency difference between each compiler; I estimate that the actualist of the standard program library has more affected. Obviously, the above C - Style solution is simplified by the C-Style solution, and can be achieved by the C standard program. Is this comparison not really enough? I do not think so. A key shape of C is that it supports the support capabilities, exquisite and efficient. The advantages of the above simple program are presented in any application - as long as there is exquisite and high-efficiency program libraries. The challenge of the C ethnic group is to expand the field, allowing general programmers to enjoy these benefits. That is, we must design and implement exquisite and efficient program libraries for more applications, and allow these programs to be widely used. Learning C Even a professional programmer, it is impossible to start the entire language of the entire language first, then start using it. The programming language should be segmented, and the various facilities are tested in small exercises. So we always learn a language in a manner of segmentation. The real problem is not "Is there a part of the language first?" And "Which part should I first learn?" About this problem, the traditional answer is "first learning C and C compatible with C Subset. But from what I think, this is not a good answer. This learning law will lead to premature focus on low-order details. It also blurred the topic of programming style and design because of forced students to face many technical difficulties, and suppressed many interesting things. The previous two examples of this article have explained this. C has a better program library support, better representation, better type test, undoubtedly voting an objection to the "C-priority". However, note that I am not said that "pure object-oriented programming style is best." I think that is another extreme. For programming beginners, learn a programming language and should cover programming techniques with actual benefits. For a programmed experience but a programs of C , its learning should focus on how to behave in C , which has practical programming technology, and a new technology for himself. The biggest trap facing experienced programs often is in an attempt to express the benefits of other languages with C . Regardless of the initiator or experienced programs, the focus should be conceptual and technically. It is second to understand the syntax and language details of C , which is secondary. The teaching is best starting from a well-selected instance, and then goes more generally more abstract direction. This is a child's learning method, and most of our people understand the way of new ideas. Language features should always be manifested in the environment they use. Otherwise, the prosecress's focus will move from the product itself to the difficult surface of the technology. Focusing on language technology details, it may be interesting, but it is not a high-efficiency education. On the other hand, only a labor behavior after programming work is analyzed and designed, is also wrong. The discussion of the actual program is put until each high-order issue and the engineering topic have been completely present, and this practice will be a costly error in many people. This practice will drive people away from programming practical work and lead to serious underestimation of many people to generate a high-quality intelligence challenge. The extreme side of "design priority" is that picking up a C compiler will start writing code. If you encounter a problem, choose the screen to see what help from the line explains. The problem with this approach is that its center of gravity is completely tilted, with only individual characteristics and individual facilities. The concept and technology of general use are not easy to learn from this way. For experienced programs, this approach is that it will expand some tendency to use the C syntax and program libraries that are inevitably unable to read the previously used language. For beginners, there will be many if-life-else codes, mixing some fragments of the examples provided by the manufacturer. The program code that is incorporated in, its original destination is often smashed, and in order to achieve the effect, the technique used can also completely exceed the scope of understanding. Even if you are wisdom, I am afraid it is difficult to flee it. This way of rewriting is rewritten, as a good course or an attached attachment of a good textbook, but it is actually very easy to lead to disasters. Briefly, the way I recommend is: • Pioneering icon, abstract • Programming technology and design technology supported by language, to express the characteristics of language. • Before going to low-order detail (that is necessary for the establishment of the program library), you will rely on the relatively high-order program. • Avoid technologies that cannot be included in real world. • Before entering the details, you can first understand the techniques and properties of common and useful • Focus on concepts and techniques (rather than the nature of the language itself), I don't think this kind of teaching is particularly novel or with obvious innovation. I think they are a common sense. However, common sense is often discarded in more exciting discussions, for example, to discuss whether to learn C before learning C , if you have to write SMALLTALK to truly understand the spirit of the object orientation, you must have a pure OO Way (whether or not, what does it mean to mean? Do you need a thorough understanding of the software development program before trying to write any code. Fortunately, the C ethnic group already has some experience, and their learning is in line with my standard. My favorite approach is that the basic language concept such as variables, declaration, recycling circles, etc., as well as an excellent program library. This program library allows students to focus on programming, rather than chaos, are like C-Style strings, and more. I recommend using C standard programs or one of them. This approach is being used in the US high school computer scientific and high school class [考 2]. More advanced education methods designed to target experienced programs have also been empirically succeeded, please see [考 3]. The covered door of these specific teaching methods is unable to provide a simple graphic program library early, and a standard program library graphics use interface. This is easy to make up, as long as we have a very simple program of commercial interface. The so-called very simple, I mean the next day of the C course, students can get started. However, there is currently not such a simple and widely used graphics library and C program library graphics. After the initial teaching (extremely relying on the re-trip library), the course can be carried out in different directions depending on the needs and interest of students. Some occasions, even C , those low-order nature that makes a hemorica, it is necessary to verify. One way to teach (or learning) indicators, transformation, configuration, etc., is how to verify how Classes is used as a learning basis. For example, String, Vector, and List Classes is a great subject matter for exploring the "Language Facility Evolution from C to C " course. But this is best not to arrange the first phase of the course. Category Classes like Vector and String, is used to manage quantities, must use free space and indicators in actual codes. Before importing those features, certain Classes, such as DATE, POINT, and COMPLEX, can also be used as a gatekeeper for CLASS implementation technology. I tend to introduce the inheritance of abstract classes and classes after discussing the container and actual technology, but there are many directions and options. The actual arrangement of the subject should be the application of the visual library. For example, a course in which the graphic program (this thing that is inevitably relying on the category inheritance) needs to introduce a multi-type (DeriveD classes) earlier. Finally, remember, learn and education C (and its corresponding design and programming technology), there is no only correct manner. After all, the students' goals are very different from the background, the background and experience of the author of the teacher and the textbook are also very different. Summary We hope that our program is easy to write, perform correct, easy to maintain, and its efficiency performance can be accepted. In order to achieve these purposes, we must design and program at a higher abstract level. Through the application of the process, such an idea can be achieved without the loss of the efficiency of the low-order style. Therefore, please stand on the shoulders of the program, stand on the shoulders of more and more program libraries (eg, C standard program) that are widely used and consistent. The amount of the program is more widely used, and it can bring greater benefits for the C ethnic group. Mushing to clearer and higher-order programming styles, education must play the main role. The C community does not require the total programs that have the lowest level language characteristics and the lowest level library facilities - they always misunderstand their inadequacy. C beginners, as well as experienced C programs, must be a higher-order language, which will decrease the abstraction to a lower level when it is absolutely necessary after some courses training. Take Standard C as a landscaping C or landscaped c with classes to play, just wasting the beautiful opportunities provided by standard C . Acknowledgments Thank Chuck Allison suggest that I write an article how to learn standard C . Thanks Andrew Koenig and Mike Yang provide a constructive advice on the preliminary draft. My program is compiled with Cygnus EGCS 1.1, which is executed in Sun UltraSPARC 10. The program in the article can be obtained from my webpage: http://www.research.att.com/~bs. Note [Note 1] For the aesthetics, I use C style symbol constant and C style // annotation . If you are strictly obeyed from ISO C, you should use #define and / * * / annotation. [Note 2] I know, here, C allows us to do not do explicit transformation.
