Tags: History of C, ANSI C, ISO C, C99, C11, ISO/IEC C, C standardization.
origins
C and is a "co-product" from the creation of the UNIX operating system, which was developed at Bell Laboratories by Ken Thompson, Denis Ritchie and co. Thompson single-handedly wrote the original version of UNIX that ran on the DEC PDP-7, one of the first minicomputers with only 8K words of main memory (it was 1969, after all).
Like other operating systems of the day, UNIX was written in assembly language. Debugging assembly language programs is a real pain and difficult to improve, and UNIX was no exception. Thompson decided that a high-level language was needed for further development of the OS and came up with a small language B. Thompson took the BCPL language, a language for system programming developed in the mid 60s. BCPL, in turn, originates from Algol 60, one of the earliest (and most influential) languages.
Ritchie soon joined the UNIX project and began writing in B. In 1970, Bell Labs purchased a PDP-11 for the project. Since B was ready to run on the PDP-11, Thompson rewrote part of UNIX to B. In 1971, it became clear that B was not quite suitable for the PDP-11, so Ritchie began to create an extended version of B. He first called it NB (New B ), but when the language became very different from B, the name was changed to C. By 1973, the language was stable enough that UNIX could be rewritten in it. The move to C provided an important benefit: portability. By writing a C compiler for each of the machines at Bell Labs, the development team could port UNIX to them.
Standardization
C continued to evolve in the 70s, especially between 1977 and 1979, when the first C book was published. The C Programming Language, written by Brian Kernighan and Denis Ritchie and published in 1978, became the bible of C programmers. In the absence of an official standard, this book - also known as the K&R, or "White Book" as C fans like to call it - has become the de facto standard. There were few C programmers in the 70s and most of them were UNIX users. However, in the 80s, C moved beyond the narrow confines of the UNIX world. C compilers have become available on various machines running various operating systems. In particular, C began to spread on the rapidly developing IBM PC platform.
Along with the rise in popularity came problems. Programmers who wrote new compilers took as a basis the language described in K&R. Unfortunately, in K&R, some features of the language were described vaguely, so compilers often interpreted them at their discretion. In addition, the book did not make a clear distinction between what is a feature of the language and what is a feature of the UNIX operating system. To make matters worse, after the publication of K&R, C continued to develop: new features were added to it and old ones were cut out of it. Soon there was an obvious need for a comprehensive, accurate and up-to-date description of the language. Without such a standard, dialects of the language began to appear that interfered with portability, the strongest side of the language.
Development of the American C standard began in 1983 under the auspices of the American National Standards Institute (ANSI). After many revisions, the standard was completed in 1988 and formally adopted in December 1989 as ANSI X3.159-1989. In 1990, it was approved by the International Organization for Standardization (ISO) as the international standard ISO/IEC 9899:1990. This version of the language is commonly referred to as C89 or C90 to avoid confusion with the original version of C, commonly referred to as K&R C.
The language underwent minor changes in 1995 (the changes are described in a document commonly referred to as Amendment 1). More significant changes occurred in 1999, when the ISO/IEC 9899:1999 standard was published. The language described in this standard is commonly referred to as C99. The terms "ANSI C", "ANSI/ISO C", and "ISO C", once used to describe C99, are ambiguous due to the existence of two standards.
In 2011, along with the C++ language revision, the C11 standard was released. Despite the existence of the 11 standard, many compilers still do not fully support even C99 versions, so the use of the C11 standard will be explicitly stated.
When your reputation works for your profit
Community management
Creation of Tone of Voice. Prompt processing of both negative and positive comments on behalf of the brand. Management of communications according to the given scenarios. Transmission of problematic moments to the customer.
Agents of influence
Creation and implementation of "virtuals" on forums and in in social networks. There is a database of pumped and live accounts on more than 300 sites.
Working with reviews
Writing, coordinating and posting brand reviews on top sites and review sites. Processing and overlapping negative comments with positive ones. As a result of search results the negative is gradually being replaced.
Social media monitoring
Working with Youscan, IQbuzz, Brand Analytics systems. Control of brand mentions. Identification of key insights, prompt response to negativity. An indispensable tool for control feedback from clients.
Analytics and Research
Analysis information field, product category research and the brand's main competitors. This tool covers tasks from reputation control and real-time marketing to in-depth research.
SERM
Detailed Analysis search results for selected keywords. Collection of mentions about the client in social networks, forums and news sites. Development of a strategy for dealing with negative information. The client receives a fully controlled issue in the TOP10.
What is the status of the C language? Historically, this language is inseparable from the Unix operating system, which is now experiencing its rebirth. The 60s were the era of the formation of operating systems and high-level programming languages. At that time, OS and compilers were independently developed for each type of computer, and often even their own programming languages (remember, for example, PL/I). At the same time, the generality of the problems that arise in this case has already become obvious. The response to the realization of this commonality was an attempt to create a universal mobile operating system, and for this it took no less universal and mobile language programming. C became that language, and Unix became the first operating system written almost entirely in a high-level language.
The close association with Unix gave C a testing ground that no other language had at the time. System programming tasks were rightfully considered the most complex in the industry at the time. For the most part, they were so machine-dependent that many did not even think of their solution in any other way than in assembler. High-level languages were intended for application programming and only very limitedly implemented the functions necessary for system work, and often only for a certain type of machine.
From the very beginning, the C language was designed so that system tasks could be written in it. The creators of C did not begin to develop an abstract model of the language executor, but simply implemented in it those features that were most needed in the practice of system programming. First of all, these were the means of direct work with memory, structural control structures and the modular organization of the program. And in fact, nothing else was included in the language. Everything else was relegated to the runtime library. Therefore, ill-wishers sometimes speak of the C language as a structural assembler. But no matter what they chatted, the approach turned out to be very successful. Thanks to him, a new level was reached in terms of the ratio of simplicity and the possibilities of the language.
There is, however, another factor that determined the success of the language. The creators very skillfully separated machine-dependent and independent properties in it. Thanks to this, most programs can be written universally - their performance does not depend on the architecture of the processor and memory. A few hardware-dependent parts of the code can be localized in individual modules. And using the preprocessor, you can create modules that, when compiled to different platforms will generate the corresponding machine-dependent code.
The syntax of the C language caused a lot of controversy. The abbreviation techniques used in it, if used excessively, can make the program completely unreadable. But, as Dijkstra said, - the means are not to blame for the fact that they are illiterately used. In fact, the syntax abbreviations proposed in C correspond to the stereotypical situations most often encountered in practice. If we consider abbreviations as idioms for the expressive and compact presentation of such situations, then their usefulness becomes unconditional and obvious.
So, C emerged as a general-purpose systems programming language. But he did not stay within these limits. By the end of the 1980s, the C language, having pushed aside Fortran from its leading position, gained massive popularity among programmers around the world and began to be used in a wide variety of applied tasks. A significant role here was played by the spread of Unix (and therefore C) in the university environment, where a new generation of programmers was trained.
Like all languages, C has evolved over time, but most of the improvements have not been radical. The most significant of these, perhaps, should be considered the introduction of a strict specification of function types, which significantly increased the reliability of inter-module interaction in C. All such improvements were enshrined in 1989 in the ANSI standard, which still defines the C language.
But if everything is so cloudless, then why do all the other languages \u200b\u200bcontinue to be used, what supports their existence? The Achilles heel of the C language was that it was too low-level for the tasks that the 90s put on the agenda. And this problem has two aspects. On the one hand, too low-level tools were built into the language - first of all, it was working with memory and address arithmetic. It is not for nothing that changing the capacity of processors has a very painful effect on many C-programs. On the other hand, C lacks high-level tools - abstract data types and objects, polymorphism, exception handling. As a consequence, in C programs, the technique for implementing a task often dominates its content.
The first attempts to correct these shortcomings began to be made in the early 1980s. Even then, Bjorn Stroustrup at AT & T Bell Labs began to develop an extension of the C language under the conditional name. The style of development was quite consistent with the spirit in which the C language itself was created - certain features were introduced into it in order to make it more convenient work specific people and groups. The first commercial translator of the new language, called C++, appeared in 1983. It was a preprocessor that translated the program into C code. However, the release of Stroustrup's book in 1985 can be considered the actual birth of the language. It was from this moment that C++ began to gain worldwide popularity.
The main innovation of C++ is the class mechanism, which makes it possible to define and use new data types. The programmer describes the internal representation of a class object and a set of method functions for accessing this representation. One of the cherished goals when creating C ++ was the desire to increase the percentage of reuse of already written code. The concept of classes offered an inheritance mechanism for this. Inheritance allows you to create new (derived) classes with extended representation and modified methods without affecting the compiled code of the original (base) classes. At the same time, inheritance provides one of the mechanisms for implementing polymorphism - the basic concept of object-oriented programming, according to which, in order to perform the same type of processing different types data, the same code can be used. Actually, polymorphism is also one of the methods for ensuring code reuse.
The introduction of classes does not exhaust all the innovations of the C++ language. It has a full-fledged structured exception handling mechanism, the absence of which in C made it much more difficult to write reliable programs, a template engine, a sophisticated macro generation mechanism deeply embedded in the language, opening up another path to code reusability, and much more.
Thus, the general line of language development was aimed at expanding its capabilities by introducing new high-level constructs while maintaining as full compatibility with ANSI C as possible. operations, so that the programmer actually stops working directly with memory and system-dependent entities. However, the language does not contain mechanisms forcing the developer to correctly structure the program, and the authors have not issued any systematic recommendations for the use of its rather sophisticated constructions. They did not take care in time and about the creation of a standard class library that implements the most common data structures.
All this led to the fact that many developers were forced to explore the labyrinths of language semantics themselves and independently look for successfully working idioms. So, for example, at the first stage of the development of the language, many creators of class libraries sought to build a single class hierarchy with a common base class Object. This idea was borrowed from Smalltalk - one of the most famous object-oriented languages. However, it turned out to be completely unviable in C++ - the carefully designed class library hierarchies turned out to be inflexible, and the work of classes was not obvious. In order for class libraries to be usable, they had to be supplied in source code.
The appearance of template classes completely refuted this direction of development. Inheritance began to be used only in cases where it was required to generate a specialized version of an existing class. Libraries began to be composed of separate classes and small unrelated hierarchies. However, code reuse began to decrease along the way, since C++ does not allow polymorphic use of classes from independent hierarchies. The widespread use of templates leads to an unacceptable increase in the amount of compiled code - let's not forget that templates are implemented using macro generation methods.
One of the worst shortcomings of C++, inherited from the syntax of C, is the availability to the compiler of the description of the internal structure of all classes used. As a result, changing the internal structure of the representation of some library class leads to the need to recompile all programs where this library is used. This greatly limits library developers in terms of their modernization, because, releasing new version, they must retain binary compatibility with the previous one. It is this problem that makes many experts believe that C++ is unsuitable for large and extra-large projects.
And yet, despite the listed shortcomings and even the unavailability of the language standard (this is after more than fifteen years of use!), C ++ remains one of the most popular programming languages. Its strength is primarily in its almost complete compatibility with the C language. Thanks to this, all the achievements made in C are available to C ++ programmers. At the same time, C ++, even without the use of classes, brings to C a number of important additional features and amenities that many people use it simply as an improved C.
Concerning object model C++, then as long as your program has not become very large (hundreds of thousands of lines), it is quite possible to use it. The recent trend of transition to component software only strengthens the position of C ++. When developing individual components, the shortcomings of C ++ do not yet appear, and the binding of components into a working system is no longer done at the language level, but at the operating system level.
In light of all that has been said, the outlook for C++ does not look bleak. Although the monopoly in the market of programming languages does not shine for him. Perhaps, we can only say with certainty that this language will not survive another modernization-extension. Not without reason, when Java appeared, so much attention was paid to it. A language close in syntax to C++, and therefore seemingly familiar to many programmers, has been spared the most egregious shortcomings of C++, which it inherited from the 70s. However, Java doesn't seem to be up to the role that some people have given it.
The special role of C/C++ languages in modern programming makes it almost pointless to give specific addresses on the Internet where you can find materials on them. There are just too many places like this. However, if you are interested in learning more about the evolution of C++, then start with a short article http://citforum.syzran.ru/programming/prg96/76.shtml.
Alexander Sergeev, [email protected]
Article from BYTE/Russia magazine, March 2000
In order to visually demonstrate the use of the described languages in practice, we chose a task in which it was required to enter a series of integers from the standard input or from a file, and then output only the odd ones, and in reverse order. This is one of the simplest problems, which essentially requires working with arrays, loops, branching, and I/O, and also allows you to demonstrate subroutine calls. At the same time, it is visible and easily perceived.
Listing 1. C
1 #include
- Line 3. In C/C++, program execution always starts with the main function.
- Lines 7 and 11. The loop header contains a semicolon to indicate the initial setting, the continuation condition, and the rule for recalculating the loop parameter. Operations ++ and -/- - the most famous of the abbreviations of the C language, meaning the increment and decrement of a variable, that is, the increase and decrease in its value by one.
- Line 8. Function scanf enters, according to the format specified by the first parameter, the values of the variables whose addresses are specified by the remaining parameters. Here, the address where the value is entered is calculated using address arithmetic, to the address of the array location M offset is added N elements. The same effect can be obtained by writing &M[N].
- Line 12. Operation % calculates the remainder of a division. Operator condition if is considered fulfilled if the numerical value of the expression is non-zero.
- Line 13. Function printf- print by format works similarly scanf, but instead of addresses, it is passed the values to be output.
- Lines 3-13. The template class is declared Array with parameter T. It is an array of variable size objects of type T. Of course, in our task there is no need to use the template class. However, we wanted to demonstrate how C++ creates a polymorphic data structure that can work with any type of element.
- Line 5. Class constructor. It initializes the representation of the object. For example, in the field M the address of the memory block ordered by the operation is entered new T.
- Line 8. An example of overloading an operation. Function operator will be called when square brackets appear to the right of the class object array.
- Line 9. This function is the main one in the implementation. It adds elements to the array, expanding it as needed. Since it is more complex than the others, its definition is taken out of the class description. The functions described in the class body are implemented in C++ not by calling, but by inline substitution. This speeds up the program, although it increases its size.
- Lines 15-24. Function definition Array::Add(T)(by the way, that's her full name).
- Line 27. Create an object of type array. Templet Aggau parameterized by type int.
Why C++
C++ is currently considered the dominant language used for developing commercial software products. In recent years, this dominance has been slightly shaken by similar claims from a programming language like Java, but the pendulum of public opinion has swung the other way, and many programmers who abandoned C++ for Java have recently rushed back to of his former affection. In any case, these two languages are so similar that by learning one of them, you automatically master 90% of the other.
C# is a new language developed by Microsoft for the networking platform. In essence, C# is a kind of C++, and despite a number of fundamental differences, the C# and C++ languages coincide by about 90%. It will probably be a long time before C# becomes a serious competitor to C++; but even if it does, knowledge of the C++ language will be a significant advantage.
C++ is a general purpose programming language. Its natural scope is system programming, understood in the broadest sense of the word. In addition, C++ is successfully used in many areas of application that go far beyond the specified scope. C++ implementations are now on every machine, from the humblest microcomputer to the largest supercomputer, and for virtually all operating systems.
The emergence and evolution of the C++ language
Bjorn Stroustrup is the developer of the C++ language and the creator of the first translator. He is an employee of the AT&T Bell Laboratories Research Computing Center in Murray Hill (New Jersey, USA). He received his Master's degree in Mathematics and Computer Engineering from the University of Aarus (Denmark) and his PhD in Computer Science from the University of Cambridge (England). He specializes in distributed systems, operating systems, modeling and programming. Together with M. A. Ellis, he is the author of a complete guide to the C++ language - "A Guide to C++ with Notes".
Of course, C++ owes a lot to the C language, which is preserved as a subset of it. All the low-level tools inherent in C, designed to solve the most pressing problems of system programming, are also preserved. C, in turn, owes a lot to its predecessor, BCPL. The BCPL language comment has been restored to C++. Another source of inspiration was the SIMULA-67 language; it was from him that the concept of classes was borrowed (together with derived classes and virtual functions). C++'s ability to overload operators and the freedom to place declarations wherever an operator may appear is reminiscent of the Algol-68 language.
Earlier versions of the language, called "C with classes", were in use starting in 1980. This language arose because the author needed to write interrupt-driven simulation programs. The SIMULA-67 language is ideal for this, apart from efficiency. The "C with classes" language was used for large modeling tasks. At that time, the possibilities of writing programs on it, for which time and memory resources are critical, were subjected to rigorous testing. This language lacked operator overloading, references, virtual functions, and many other features. For the first time, C++ left the research group where the author worked in July 1983, but at that time many C++ features had not yet been developed.
The name C++ (C plus plus) was coined by Rick Maschitti in the summer of 1983. This name reflects the evolutionary nature of the changes in the C language. The notation ++ refers to the C increment operation. The slightly shorter name C+ is a syntax error. In addition, it has already been used as the name of a completely different language. C semanticists find that C++ is worse than ++C. The language is not called D because it is an extension of C, and it does not attempt to solve any problems by dropping C features. Another interesting interpretation of the C++ name can be found in the appendix to .
C++ was originally conceived so that the author and his friends did not have to program in assembly, C, or other modern high-level languages. Its main purpose is to simplify and make more enjoyable the programming process for the individual programmer. Until recently, there was no C++ development plan on paper. Design, implementation and documentation went hand in hand. There has never been a "C++ Project" or "C++ Design Committee". Therefore, the language has evolved and continues to evolve in such a way as to overcome all the problems that users have encountered. Discussions by the author of all problems with his friends and colleagues also serve as impetus for development.
Since the publication of the first edition of this book, the C++ language has undergone significant changes and refinements. It's mainly about overload disambiguation, linking, and memory management. However, minor changes have been made to increase compatibility with the C language. Some generalizations and significant extensions have also been introduced, such as multiple inheritance, member functions with static and const specifications, protected members (protected), type templates, and handling special situations. All these extensions and improvements were aimed at making C++ a language in which libraries can be created and used. All changes are described in .
Other extensions introduced between 1985 and 1991 (such as multiple inheritance, static member functions, and pure virtual functions) emerged from generalizations of C++ programming experience rather than from other languages.
The language extensions made during these six years were primarily aimed at increasing the expressiveness of C ++ as a data abstraction language and object-oriented programming in general and as a means for creating high-quality libraries with user-defined data types in particular.
Around 1987, it became apparent that C++ standardization work was imminent and that the foundation for it should be started immediately.
AT&T Bell Laboratories was the main contributor to this work. About a hundred representatives from about 20 organizations studied and commented on what became the modern version of the reference manual and source material for ANSI standardization. C++. Finally, at the initiative of Hewlett-Packard, in December 1989, Committee X3J16 was formed within ANSI. It is expected that C++ standardization work in ANSI (American Standard) will become an integral part of the ISO (International Standards Organization) standardization work.
C++ has evolved along with the development of some of the fundamental classes.
History of creation
The language originated in the early 1980s, when Bell Labs employee Björn Stroustrup came up with a number of improvements to the C language for his own needs. When Stroustrup began working at Bell Labs in the late 1970s on problems in queuing theory (as applied to modeling telephone calls), he found that attempts to use existing modeling languages at the time were ineffective, and the use of highly efficient machine languages was too difficult because for their limited expressiveness. For example, the Simula language has features that would be very useful for developing large software, but is too slow, and the BCPL language is fast enough, but too close to low-level languages, and is not suitable for developing large software.
Recalling the experience of his dissertation, Stroustrup decided to supplement the C language (the successor to BCPL) with the capabilities available in the Simula language. The C language, being the base language of the UNIX system on which the Bell computers ran, is fast, feature rich, and portable. Stroustrup added to it the ability to work with classes and objects. As a result, practical modeling problems turned out to be accessible both in terms of development time (due to the use of Simula-like classes) and in terms of computation time (due to the speed of C). The first additions to C were classes (with encapsulation), class inheritance, strong type checking, inline functions, and default arguments. Early versions of the language, originally called "C with classes", have been available since 1980.
While developing C with classes, Stroustrup wrote the cfront program, a compiler that converts C source code with classes into plain C source code. This made it possible to work on a new language and use it in practice, using the infrastructure already available in UNIX for development in C. A new language, unexpectedly for the author, he gained great popularity among colleagues and soon Stroustrup could no longer personally support him, answering thousands of questions.
When creating C++, Bjorn Stroustrup wanted- Get a universal language with static data types, the efficiency and portability of C.
- Directly and comprehensively support many programming styles, including procedural programming, data abstraction, object-oriented programming, and generic programming.
- Give the programmer freedom of choice, even if it gives him the opportunity to choose incorrectly.
- Keep compatibility with C as much as possible, thereby making it possible to easily switch from programming to C.
- Avoid confusion between C and C++: any construct allowed in both languages must mean the same thing in each of them and lead to the same program behavior.
- Avoid features that are platform dependent or not universal.
- "Don't pay for what you don't use" - No language feature should cause performance degradation for programs that do not use it.
- Do not require too complicated programming environment.
Despite a number of well-known shortcomings of the C language, Stroustrup chose to use it as a base because "C has its problems, but a language developed from scratch would have them, and we know the problems of C." In addition, this made it possible to quickly obtain a compiler prototype (cfront), which only translated the added syntax elements into the original C language.The choice of C as the basis for creating a new programming language is explained by the fact that the C language:
1. is a multi-purpose, concise and relatively low-level language;
2. suitable for solving most system problems;
3. executed everywhere and on everything;
4. interfaces with the UNIX programming environment.— B. Stroustrup. C++ programming language. Section 1.6
As C++ was developed, other features were included that overlapped the capabilities of C constructs, in connection with which the question of abandoning language compatibility by removing deprecated constructs was repeatedly raised. However, compatibility has been maintained for the following reasons:
- preservation of the current code, originally written in C and directly ported to C ++;
- eliminating the need to retrain programmers who have previously studied C (they only need to learn new C++ tools);
- the elimination of confusion between languages when they are used together (“if two languages are used together, their differences should be either minimal or so large that the languages cannot be confused”).
By 1983, new features were added to the language, such as virtual functions, function and operator overloading, references, constants, user control over free memory management, improved type checking, and a new comment style (//). The resulting language is no longer just an augmented version of classic C and has been renamed from C with classes to "C++". Its first commercial release took place in October 1985.
The resulting language name comes from the C++ unary postfix increment operator (incrementing the value of a variable by one).
Prior to the start of official standardization, the language was developed mainly by Stroustrup in response to requests from the programming community. The function of standard language descriptions was performed by Stroustrup's printed works on C ++ (a description of the language, a reference manual, and so on).
History of standards
In 1985, the first edition of The C++ Programming Language came out, providing the first description of the language, which was extremely important due to the lack of an official standard.
In 1989, C++ version 2.0 was released. Its new features included multiple inheritance, abstract classes, static member functions, constant functions, and protected members. In 1990, the "Commented Reference Guide to C++" was published, which later became the basis of the standard. Recent updates have included templates, exceptions, namespaces, new casts, and the boolean type.
The C++ Standard Library has also evolved along with it. The first addition to the C++ standard library was I/O streams, providing a means to replace the traditional C printf and scanf functions. Later, the most significant development of the standard library was the inclusion of the Standard Template Library.In 1998, the language standard ISO/IEC 14882:1998 (known as C++98) was published by the C++ Standards Committee (ISO/IEC JTC1/SC22/WG21 working group). The C++ standard does not describe how objects are named, some exception handling details, and other implementation-related features, making object code generated by different compilers incompatible. However, many standards have been created by third parties for specific architectures and operating systems.
In 2005, Library Technical Report 1 (abbreviated as TR1) was released. Although not officially part of the standard, the report describes extensions to the standard library that the authors expected to be included in the next version of the C++ language. TR1 support is improving in almost all supported C++ compilers.
Since 2009, work has been underway to update the previous standard, the preliminary version of the new standard was first C ++ 09, and a year later C ++ 0x, today C ++ 11, which included additions to the language core and an extension to the standard library, including including most of TR1.
C++ continues to evolve to meet modern requirements. One of the groups that develop the C ++ language and send proposals to the C ++ standardization committee for its improvement is Boost, which is also engaged in improving the capabilities of the language by adding metaprogramming features to it.
No one owns the rights to the C++ language, it is free. However, the language standard document itself (with the exception of drafts) is not available for free.