Talk about OOP

OOP : Object oriented programming, Object Of ProgramDesign . The so-called "object" is one or a group Data And a set of methods and processes for processing the data. Object-Oriented Programming is completely different from traditional process-oriented programming, which greatly reduces Software The difficulty of development makes Programming As simple as building blocks, it is an unstoppable trend in today's computer programming.
Object-Oriented Programming (OOP) is a computer programming architecture. One basic principle of OOP is that a computer program is composed of a single unit or object that can act as a subroutine. Oop has achieved three main objectives of Software Engineering: reusability, flexibility, and scalability. To achieve the overall operation, each object can receive, process, and send information to other objects. Oop has the following concepts and components:
Component-a unit formed by data and functions in a running computer program. components are the basis of modules and structures in OOP computer programs.
Abstraction-the Program has the ability to ignore some aspects of the information being processed, that is, the ability to focus on the main aspects of information.
Encapsulation-it is also called Information encapsulation: to ensure that the component does not change the internal status of other components in an unpredictable way; only in those components that provide the internal state change method, to access its internal status. Each type of component provides an interface for contacting other components and specifies the method for calling other components.
Polymorphism-the reference and class assembly of components involve many other different types of components, and the result of referencing components must be based on the actual call type.
Inheritance-allows sub-components to be created based on existing components, which unifies and enhances polymorphism and encapsulation. Typically, classes are used to group components, and new classes can be defined as extensions of existing classes, so that classes can be organized into a tree or mesh structure, this reflects the versatility of the action.
Because of abstraction, encapsulation, reusability, and ease of use, component-based programming has become particularly popular in scripting languages. Python and Ruby are recent languages that fully adopt the idea of OOP during development, the popular perl scripting language has gradually added new object-oriented functional components since version 5. Replacing "reality" entities with components has become the reason why JavaScript (ecmascript) becomes popular, it has been demonstrated that appropriate combinations of components can replace the HTML and XML Document Object Model (DOM) on the English site ).

[Edit this section]

I. Basic Idea of OOP

Many of the original ideas of OOP come from the simula language, and get more extensions and re-annotations of previous ideas in the process of improving and standardizing the Smalltalk language. It can be said that OO ideas and oopl are almost synchronous development and mutual promotion. Unlike functional-programming and logic-programming, oop hardly introduces accurate mathematical descriptions, but tends to establish an object model, which can reflect the relationship between entities in the application field, its essence is a computational model that is closer to the philosophical view adopted by human cognition. This leads to a natural topic, that is, what is oop? [D & t 1988] [B .s 1991]. In Oop, an object, as the computing subject, has its own name, status, and interface for receiving external messages. In the object model, new objects are generated, old objects are destroyed, messages are sent, and response messages constitute the foundation of the OOP computing model.
There are two basic methods to generate an object. A new object is generated based on a prototype object. A new object is generated based on a class. The concept of prototype has been used in cognitive psychology to explain the increasing feature of concept learning. The prototype itself attempts to generate various new objects by providing a representative object, and then generate objects that are more in line with the actual application. Prototype-delegation is also the object abstraction in OOP, Code Sharing Mechanism. A class provides a general description of one or more objects. From a formal perspective, classes are related to types. Therefore, a class is equivalent to a set of instances generated from this class. However, such a viewpoint will bring about some contradictions. A typical example is that in the inheritance system, the subset (subclass) object and the parent set (parent class) the behavior convergence between objects may be difficult to achieve, that is, the sub-type that is often referenced in OOP is not equal to the sub-class (subclass) [Budd 2002]. In the context of an object-oriented world view, a new object model with metaclass is created based on the class model. That is, the class itself is also an object of another class. The three different viewpoints define three class-based, prototype-based, and metaclass-based object models. These three object models lead to many different programming languages (if we temporarily put the difference between static and dynamic ). Yes, we often use class-based object models in C ++ and Java, but there are also a lot of oopl that we don't have to deal with using completely different object models, they are interpreting the connotation of OOP from another perspective.
What is the basic idea of OOP? Separate component implementations from interfaces and make the components have polymorphism. However, there is a fundamental difference between the two. Oop emphasizes the syntax of language elements in program construction. You must inherit, use classes, use objects, and objects to transmit messages. GP doesn't care whether you inherit or not. It begins with analyzing product categories, what types of products, and how they behave. That is to say, what does two things mean when they are equal? How to correctly define equal operations? It is not just as simple as equal operations. If you analyze them in depth, you will find that the general idea of "equal" means that the two object parts, or at least the basic parts, are equal, therefore, we can have a general equality operation. The object type. Suppose there is a sequence and a group of operations on the sequence. So what are the meanings of these operations? From the perspective of complexity trade-offs, what sequence should we provide to users? What operations exist in this sequence? What sort is what we need? Only by clarifying the conceptual classification of these components can we mention the implementation problem: using templates, inheritance, or Macros? What languages and technologies are used? The basic idea of GP is to classify abstract software components and their behaviors in a standard taxonomy. The starting point is to build a true, efficient, and language-independent Algorithm And data structure. Of course, the ultimate carrier is language, and no language can be programmed. STL uses C ++. You can also implement it using ADA. You can implement it using other languages. The results will be different, but the basic things are the same. Binary Search and sorting are used everywhere, and this is what people are doing. For the container semantics, different languages may bring slight differences. However, the basic difference is clearly the semantics of GP dependency and semantic decomposition. For example, we decided to need a component swap and then pointed out that the component would work in different languages. Obviously, the focus is on semantics and semantic classification. What OOP emphasizes (I think it is too much) is to clearly define the hierarchy between classes. Oop tells you how to establish hierarchical relationships, but does not tell you the essence of these relationships.
(This section is not very easy to understand. Some terms may take some time to have a proper Chinese translation-the translator)
Object-Oriented Programming Method OOP was a popular software programming method in 1990s. It emphasizes the "abstraction", "encapsulation", "inheritance", and "polymorphism" of objects ". The program design is composed of "Data Structure" and "algorithm. From a macro perspective, the objects in OOP are program-oriented objects. What we want to talk about today is information-oriented and user-centered.

[Edit this section]

Ii. History of OOP Technology

Object-oriented technology was initially designed for Object-Oriented Programming, and its appearance was marked by the simula language in 1960s. In the middle and late 1980s S, object-oriented programming gradually matured and was understood and accepted by the computer industry. People began to further consider the issue of object-oriented development. This is the background of the popularity of Microsoft Visual OOP Software in 1990s.
Traditional structured analysis and design and development methods are a linear process. Therefore, traditional structural analysis and design methods require business management specifications of the real system and complete data processing, users can fully meet their business needs.
Traditional software structures and design methods are difficult to adapt to the requirements of software production automation, because they combine process-centric functions, and the ability to expand and reuse software is very poor.
The object is a simulation of real-world entities, because it is easier to understand the needs, even if users and analysts have different educational backgrounds and work characteristics, they can also communicate well.
The differences between object-oriented development and traditional process development are: Object Recognition and abstraction, encapsulation, polymorphism and inheritance.
An object is an abstraction of a real entity. It is defined by the process or information sacrifice of a real entity. An object can be considered as an entity that encapsulates data (attributes) and programs (methods, this program generates the action of the object or the response to the external signal it receives. These object operations are sometimes called methods. An object is a dynamic concept. Its Attributes reflect the current state of the object.
Class is used to describe the set of objects with the same attributes and methods. It defines the attributes and Methods shared by each object in the set. The object is a class instance.
From the above analysis, it is not difficult to see that although OOP technology is more interested in the user object model, its purpose is to program, rather than focusing on user information, I always want to include user information in the "program object" that a user is not interested in.

[Edit this section]

Iii. Advantages and Disadvantages of OOP

· Advantages of OOP: it brings people's programming closer to the real world. All objects are Assigned attributes and methods, and result programming is more humane.
· OOP also has its disadvantages. As for C ++, C ++ has to sacrifice its performance when implementing a higher logic abstraction layer, sometimes even fatal (all object attributes are indirectly referenced by multiple built-in pointers, which is one of the main causes of performance loss; however, the limitations of the author are that I have never used any object-oriented language outside of VC ++, so I am not very sure. Haha, some people laughed... ).
Today, with the rapid development of computers, you may say that a little bit of performance sacrifice is no big deal. Yes, from an object-oriented perspective, the programming structure is clearer and more complete, data is more independent and easier to manage, and the sacrifice of performance can bring so many benefits, is there no reason not to make a steady profit?
However, in some special scenarios where the speed requirement is extremely high, for example, if you are using a telecommunications exchange system, more than one million people will exchange phone calls at the same time every second. If, every data exchange process is an object, so the total performance loss will be astronomical !!
Or this example is not close enough. Let's take another example. If you are employed by a game design company, the boss hopes that the game can be used by more computer users, and the game can run more frames per second, bullets and explosives can be more and more gorgeous. Then, you will find that using C ++ will cause your program to become clumsy and unable to meet your needs, unless you have to run your game on the Pentium 4 machine (if not, and you insist on using C ++ object programming, so please reduce the power of the protagonist's gun ).
If you are a stubborn person and you say you don't believe that OOP will cause performance loss, I remember the discussion on VB and VC execution efficiency on csdn.ArticleAfter using MFC, the execution efficiency is even lower than that developed by VB. Please verify: If the pure C language syntax is used, it will be much faster than what is compiled in VB. (For the gettickcount function, refer to msdn, to be more precise, you can use the queryperformancecounter function ).

[Edit this section]

Iv. Future of OOP

(Written by/Bjarne stroustrup & Tim Linde compilation/Meng Yan)
What changes will happen to the way programmers write code in the next three years?
Stroustrup: In C ++, it may be complicated to complete any important work without proper libraries. Once a suitable database is available, everything can be controlled by us. As a result, the importance of building and using libraries is growing. This also implies that generic programming will be applied more and more. Only through GP can we ensure the versatility and efficiency of the database. I also expect an impressive growth in distributed computing and component applications. For most programmers, these development work becomes simple and clear by using a library that is suitable for use.
There is a trend that compiler vendors are trying to sell their unique "Object Model" and graphical interface (GUI) details to users. For example, Microsoft's com and inprise class attributes "properties ". This is neither necessary nor reluctant for users. The library I Want To See should be a library built with standard C ++ with flexible and trustworthy interfaces. Generally, these interfaces are platform-independent. C ++ has a strong ability to express itself. Even if a large number of macros are not used, it should be sufficient to meet this requirement. Even if the principle cannot be fully adhered to in some places, the dependence on platforms and manufacturers should be limited. The achievement of this goal reflects the importance of the software and tools industry to the application development industry. I suspect that there is no corresponding market for independent and cross-platform vendors. If such a market can be established, vendors may be able to make "really useful" products for customers.
Linde: For code developers, the main driving force is still two: Network and distributed-that is, the need to design and develop non-standalone software. Most applications will not run on a single device, but use platform-independent distributed programs like EJB and JSP. Programmers will have to face the danger of distributed computing. This poses a severe challenge to the design patterns, technologies, and intuition on which many programmers depend. This is the choiceProgramming Language It must be recognized earlier that, although the design features of different languages may promote or impede this transformation.
An important part of the growth in network applications is the explosive growth of small mobile devices and special Internet devices. Each of these devices has its own operating system, or only has a common operating system in a specific device field. We can also list these devices, including home access devices, cellular phones, electronic newspapers, PDAs, and automatic network devices. However, the quantity and depth of these device fields will soon become incalculable. We all know that the market is amazing, and the rise of PC is nothing more than a piece of cake. Therefore, the competition in the application market for these devices will be quite cruel. One of the important means to win is to enter the market as soon as possible. Developers need excellent tools to quickly and efficiently write and debug their software. Platform independence is also one of the secrets to success. It enables programmers to develop software that supports multiple device platforms.
Another change I expected is that our development capabilities for code (Java) and data (XML) collaborative applications will continue to improve. This collaboration is one of the core goals of developing powerful applications. We have seen this trend from the rapid prevalence of XML and the Development of ebXML specifications. EbXML is an open XML-based infrastructure for e-commerce and international trade. It is organized by the United Nations Trade Promotion and E-Commerce centre (UN/CEFACT) and structural information standard promotion organization (OASIS) develop together.
Can we expect a true component-oriented language? Who will it be created?
Stroustrup: I suspect that this field lacks results because people-primarily non-programmers-have placed too many expectations on the vague words "components. These people dream that one day, components will drive programmers out of the stage of history in some way. In the future, the competent "designers" only need to use the pre-adjusted components to drag and drop the mouse, and then combine the system. For software tool vendors, this idea has another significance. They believe that only they can retain the necessary technology and be able to write such components.
This idea has one of the most basic mistakes: this component is hard to be widely welcomed. A separate component or framework is a cost-effective product for the manufacturer if it can meet most of the requirements put forward by an application or industry, it is not technically difficult. However, several competitors in the industry will soon find that if everyone uses these components, the products between them will become the same and there is no difference, they will become simple clerks, and their major profits will all go into the pockets of those component/framework suppliers!
Small "components" are very useful, but cannot produce the expected leverage effect. Medium-sized and more general components are very useful, but they require extraordinary elasticity during construction.
In C ++, we have made some progress in this regard by using class hierarchies in different forms of sharing and using interfaces carefully crafted by templates. I look forward to some interesting and useful results in this field, but I think this result is probably a new C ++ programming style, not a new language.
Linde: Writing component-oriented applications is more of a matter of investment, design, and programmer management than a programming language. Of course, some languages have inherent advantages in this regard. However, if there is any magic new language that can greatly simplify the difficulty of component writing, it is purely misleading.
Microsoft has put all its bets on C #. Where can other languages go?
Stroustrup: C ++ will remain a mainstream language in the next decade. In the face of new challenges, it will rise to respond. A language that has created so many outstanding systems will never "sit down and see the spring ".
I hope Microsoft can realize that it has huge benefits in C ++ (I am referring to ISO Standard C ++, c ++ is a bridge between it and other people in the IT world. It is an effective tool for constructing large systems and embedded systems, and is also a powerful tool to meet high-performance requirements. Other languages seem to focus more on the stable commercial applications.
Competition
C # will it be widely accepted and squeeze out other languages?
Linda: normally, a language is neither profitable nor squeezed out from other languages. Are those strong Fortran programmers still using FORTRAN? For individuals, the choice of language is certainly from time to time, but on the whole, the types of language will only increase, that is, the relationship between them is "you and me", not "you and me ".
The degree of acceptance of a new language often depends on its ability. Java technology was quickly accepted because of many factors. the frustration of the Internet and World Wide Web interfaces in front of other technologies and the overall influence on the development direction of Java technology are all the reasons. Another important reason is that Java is independent of the vendor, which means you can easily choose compatible products.
C # will it be widely accepted? Depends on the situation. In general, programmers who are indifferent to platform independence and vendor independence may like C #. Those bundled with the Microsoft platform may, of course, want to find a great alternative to VB and VC. However, programmers who are particularly concerned about cross-platform execution capabilities of programs will stick to languages such as Java. This capability is critical to multiple access devices and distributed computing models. Java provides a standard runtime environment independent of the vendor.
Stroustrup: the popularity of C # depends almost entirely on the amount of money invested by Microsoft. It seems that the rise of C # will certainly sacrifice the interests of some other languages, but in fact it may not. The vigorous development of Java has not led to the decline of C ++. The Application of C ++ is still growing steadily (of course, it is no longer an explosive growth ). Maybe other languages can have their own place.
However, I don't see any need to invent a new proprietary language. Especially for Microsoft, why C # Is it necessary to generate VB #?

[Edit this section]

5. What are the advantages and disadvantages of different OOP languages?

Stroustrup: the advantages of C ++ are as follows: flexible, efficient, and not a proprietary language. Now the emergence of the iso c ++ standard has consolidated the last point.
I think the efficiency of C ++ is its basic advantage. This efficiency comes from its unique data and computing model. Compared with Java and C #, this model is closer to machines. However, which programs are really eager for such high efficiency? This is a problem. I think there are many such programs. People's expectations for computers will always surpass the development speed of hardware technology. Obviously, designers of Java and C # have different ideas. They think that efficiency is irrelevant in many places.
C ++'s main disadvantage lies in poor education (people who always think C ++ is a pure object-oriented language, this is the case with those who regard C ++ as a C language variant). It is blamed for inconsistency on different platforms and for incomplete and non-standard compiler implementations, it is blamed for the lack of platform-independent system-level libraries.
These problems are attributed to the lack of a superior vendor that can meet the needs of the entire c ++ Community And have the courage to invest a lot of money to develop necessary libraries.
The success of the Java technology is because it appears at the right place at the right time and selects the support targets of the language and computing platform reasonably. Java is not superior to other OOP languages in all cases, but it can solve new problems very well. It is oriented to the Internet computing environment, avoiding the obscure structure in C ++ and successfully turning over the annoying problem of the Inheritance Mechanism. The garbage collection mechanism significantly increases productivity and reduces complexity. The use of virtual machines in the network context, as well as a series of design choices for security and dynamic loading, cater to the emerging needs and aspirations. These features make Java not only a new weapon for existing programmers, but also create a prosperous market space for new programmers.
In addition, Java has a standardized binary class library that provides the necessary (not adequate) platform irrelevant to the vendor. Platform and vendor independence require a technology that must have clear specifications and discard the features that impede the implementation of binary standards. Although C ++ has an ISO standard, it does not come up with a practical binary standard that is compatible with different versions even for platforms of the same system and the same command system.
In history, many languages that use virtual machines have been blamed for poor performance, which is attributed to overly slow interpreters and bad garbage collectors. Early Java implementations were also severely criticized for the same problem. However, since then, the industry has invested a lot of money to implement new virtual machines and has achieved remarkable results. In most cases, Java's performance is no inferior to that of conventional static compilation languages. This makes it unnecessary for programmers to pay performance costs when obtaining the platform and vendor independence.
C ++ does not enforce the use of object-oriented methods. Therefore, to write good object-oriented code, programmers are required to have a strong degree of discipline. Many companies give up C ++ for this reason. As a language, a prominent advantage of Java is that it forces object-oriented methods and does not allow non-object-oriented structures.
C # is between C ++ and Java, so it is neither safe nor complicated.
For a company, it is costly to adopt a new language. No good programmers can be hired (no one is familiar with this new language), training costs are astonishing, productivity and product quality are declining during the learning process, and years of experience is gone with the wind. How can a language overcome these obstacles?
Linda: That's right. Using new things is often costly. But the question is: can this new thing save more money or provide great improvements to get a reasonable return? Many companies have found that turning to Java technology, whether at the backend of Development (entering the market as soon as possible, fast iterative development, and maintaining simplicity) or front-end (cross-platform release, applicable to technologies that range from low-end devices to high-end servers, with high security), can save a lot of overhead.
The acceptance of new things is often under the pressure of pain. To a large extent, this is exactly what Java has experienced. The emergence of Java is a response to many system defects at that time. Java reduces developers' pain points through the following methods: 1) taking into account the needs of network computing, it came into being. 2) maintain a good taste in the selection of technical capabilities, taking into account the psychology of the masses. 3) Adopt a moderately mandatory strategy to implement design decisions. In addition, Java technology has become the mainstream in university teaching, which also ensures the continuous growth of Java developers.
But the most important thing is that there is no other programming technology that allows programmers to develop applications on different Internet-based platforms like Java. The outstanding performance of the Java platform in this regard has been proven by a large number of examples. Java has become the default application platform on the Internet, and Java APIs has become the natural Platform for Internet application development.
Stroustrup: Microsoft and sun threw large amounts of money into Java, VB, and C #, not because of his conscience, it is not because they really believe that these languages can bring a better life for programmers, but because of the benefits.
There is a saying that software tool vendors will obtain huge economic benefits if they can afford the professional technical tasks of application developers. I have doubts about the economic analysis behind it, and I think it is difficult to become a reality. Especially when application developers use open and standardized tools, they can have multiple options, this makes the above idea more impossible.
Many years ago, C ++ already had generic capabilities (namely, templates and STL), Operator overloading, and enumeration types? Will we see these features in future Java versions? Should Java incorporate these features?
Strousturp: C ++ has templates since. However, we spent a lot of time learning how to best use this tool. In the early days, various manufacturers also had great quality differences in template support. Some compiler manufacturers are slow, and at least one major compiler vendor (like Microsoft, Microsoft started to support template in Visual C ++ 4.0, previously, it has been claimed that the template is too complex and useless. Today, Visual C ++ has the worst support for the template in mainstream compilers) secretly encouraged the notorious anti-template promotion until they finally learned the technology. Until today, the quality of template support remains to be improved.
The features you mentioned above, I think Java (and C #) should be gradually introduced. The language features and concepts that are most useful to programmers will gradually become the inevitable choice for mainstream languages. That is to say, I think mechanisms like destructor and template specialization are much more important than enumeration mechanisms.
Lindholm: one of the reasons for the success of Java technology is that it is clear what should not be done. We have to ask why: Is this feature essential? What overhead does it bring? Operator Overloading is an extremely powerful feature in C ++, but it also greatly increases the complexity of the C ++ language, making it difficult for many people. Java makes a wise choice among various possible trade-offs and finds the perfect balance between capabilities and requirements.
Of course, Java will also develop, and the most important thing is that developers are promoting development now. Java's increase in generics demonstrates how Java uses the participation of the entire developer community to determine the correct balance between trade-offs. The "Java specification request (JSR)" (Java specification request, JSR) for adding a generic type (generic types) has already entered the JCP (Java Community process) program, it has been developed for a long time (see http://java.sun.com/aboutjava/communityprocess/jsr-014 ). At present, more than 80 jsrs are under discussion in JCP, which fully reflects the positive feedback and high cooperation from the entire system to developers. This is the driving force for the continuous evolution of the Java platform.

[Edit this section]

6. Development vs. Innovation

(Evolution vs. Revolution)
C ++ is a developer language. Java and C # seem more like innovative languages (they are designed from scratch )? When is innovative language necessary?
Linde: the Java technology is not born out of thin air, but more like a developer. All Java features existed in at least another environment before the Java platform was launched. The contribution of Java lies in the fact that a reasonable choice has been made among many features and trade-offs, making the product both practical and elegant. The attitude of Java to programmers is: raising, but not loving.
Stroustrup: Technically speaking, I don't think Java and C # are innovative languages designed from scratch. If Java is based on technical principles and designed from scratch, it will probably not imitate the ugly and pathological Syntax of C/C ++ (Don't be surprised, stroustrup has said in many occasions, c ++ adopts the C syntax, which is forced by compatibility. He prefers the syntax of simula ).
I think that only when programmers have fundamentally changed the problems they are facing, or when we discover new and extremely superior programming technologies, we only need a brand new language when it is completely not supported by existing languages. The problem is that we may never be able to see the "fundamental" and "brand new" situations.
I thought that since the advent of OOP, only the generic programming and Generative programming technologies were available, these two technologies are mainly derived from the application of the C ++ templates technology, and are also considered as secondary components of object-oriented and functional languages, now, they all become formal, available, and affordable technologies. I am very excited about the results of the current C ++ template program design. For example, libraries such as pooma, blitz ++, and MTL have changed the numerical calculation method in many places.
A selling point of C # is their simplicity. Is Java losing its selling point now?
Stroustrup: the new language always claims how simple it is and has a lot of criticism for the complexity of the old language. In fact, this so-called "Simplicity" means immaturity. The complexity of language is gradually increasing in the process of solving extremely cumbersome and special complex problems in the real world. As long as a language remains active for a long time, there will always be some areas of complexity, or the language itself, or libraries and tools. C ++ and Java are obviously no exception. I think C # is the same. If a language can survive its childhood, it will find that its size and complexity have greatly increased.
Linkholm: The functions of Java technology are being added, and things to be learned are also being added. However, the increase in functions does not necessarily increase complexity. The development of Java technology does not make the learning curve more steep, but just let it continue to extend to the right.
Standard
What are the advantages and disadvantages of standardized and open languages?
Linde: it does not have any disadvantages for an open, private extension not allowed, authoritative mandatory standard language or runtime environment. Allowing proprietary extensions means allowing the vendor to hijack customers. It is particularly important that the entire platform, not just a part of it, must be fully standardized to prevent manufacturers from using high-level proprietary APIs. Customers require the freedom to select a vendor. They must be creative and compatible.
Stroustrup: for a language such as C/C ++, the biggest advantage of establishing formal standards (such as ISO standards) is to prevent a vendor from manipulating the language, use it as your own cash tree. The competition from multiple vendors brings lower price and better stability to users.
The advantages of proprietary languages are popularity, cheap (but the situation will change when you are stuck), and quick response to commercial needs.
One of the characteristics of a standardized language is that it cannot ignore the needs of special users. For example, the scale, reliability, and efficiency requirements of what I have considered at at&t are simply different from those of the public software that the general vendors are concerned. Naturally, those companies only focus on their main needs.
However, most large organizations and cutting-edge companies have special requirements. The C ++ design is open, flexible, and efficient, and can meet any needs I can imagine. Compared with other modern languages, C ++ has little parental style, which is the reason for this. Of course, those who cannot appreciate this will criticize C ++ for its "danger ".
Languages with formal and open standards mainly serve users and customers of programming tools, while languages with exclusive "standards" mainly serve vendors.