Object-Orientation and C++编程外文文献及中文翻译
外文资料原文
Object-Orientation and C++
C++ is just one of many programming languages in use today. Why are there so many languages? Why do new ones appear every few years? Programming languages have evolved to help programmers ease the transition from design to implementation. The first programming languages were very dependent on the underlying machine architecture. Writing programs at this level of detail is very cumbersome. Just as hardware engineers learned how to build computer systems out of other components, language designers also realized that programs could be written at a much higher level, thereby shielding the programmer from the details of the underlying machine.
Why are there such a large number of high-level programming languages? There are languages for accessing large inventory databases, formatting financial reports, controlling robots on the factory floor, processing lists, controlling satellites in real time, simulating a nuclear reactor, predicting changing atmospheric conditions, playing chess, and drawing circuit boards. Each of these problems requires different sets of data structures and algorithms. Programming languages are tools to help us solve problems. However, there is not one programming language that is best for every type of problem. New programming languages are often developed to provide better tools for solving a particular class of problems. Other languages are intended to be useful for a variety of problem domains and are more general purpose.
Each programming language imparts a particular programming style or design philosophy on its programmers. With the multitude of programming languages available today, a number of such design philosophies have emerged. These design philosophies, called programming paradigms, help us to think about problems and formulate solutions.
1.Software Design through Paradigms
When designing small computer programs or large software systems, we often
have a mental model of the problem we are trying to solve. How do we devise a mental model of a software system? Programming paradigms offer many different ways of designing and thinking about software systems. A paradigm can be thought of as a mental model or as a framework for designing and describing a software system's structure. The model helps us think about and formulate solutions.
We can use the mental model of a paradigm independently from the programming language chosen for implementation. However, when the chosen language provides constructs and mechanisms that are similar to those that are found in the paradigm, the implementation will be more straightforward. Usually, there are several languages that belong to a paradigm. For this reason, a programming paradigm is also considered a class of languages.
A language does not have to fit into just one paradigm. More often, languages provide features or characteristics from several paradigms. Hybrid languages, such as C++, combine characteristics from two or more paradigms. C++ includes characteristics from the imperative and procedural paradigms -- just like its predecessor language, C -- and the object-oriented paradigm.
THE IMPERATIVE PARADIGM. The imperative paradigm is characterized by an abstract model of a computer with a large memory store. This is the classic von Neumann model of computer architecture. Computations, which consist of a sequence of commands, are stored as encoding within the store. Commands enable the machine to find solutions using assignment to modify the store, variables to read the store, arithmetic and logic to evaluate expressions, and conditional branching to control the flow of execution.
THE PROCEDURAL PARADIGM. The procedural paradigm includes the imperative paradigm, but extends it with an abstraction mechanism for generalizing commands and expressions into procedures. Parameters, which are essentially aliases for a portion of the store, were also introduced by this paradigm. Other features include iteration, recursion, and selection. Most mainstreams programming today is done in a procedural language.
The procedural paradigm was the first paradigm to introduce the notion of
abstraction into program design. The purpose of abstraction in programming is to separate behavior from implementation. Procedures are a form of abstraction. The procedure performs some task or function. Other parts of the program call the procedure, knowing that it will perform the task correctly and efficiently, but without knowing exactly how the procedure is implemented.
THE PROCEDURAL PARADIGM WITH ADTs.DATA ABSTRACTION is concerned with separating the behavior of a data object from its representation or implementation. For example, a stack contains the operations Push, Pop, and IsEmpty.
A stack object provides users with these operations, but does not reveal how the stack is actually implemented. The stack could be implemented using an array or a list. Users of the stack object do not care how the stack is implemented, only that it performs the above operations correctly and efficiently. Because the underlying implementation of the data object is hidden from its users, the implementation can easily be changed without affecting the programs that use it.
When we design algorithms, we often need a particular data type to use in order to carry out the algorithm's operations. The design of an algorithm is easier if we simply specify the data types of the variables, without worrying about how the actual data type is implemented. We describe the data type by its properties and operations and assume that whatever implementation is chosen, the operations will work correctly and efficiently. Types defined in this way are called ABSTRACT DATA TYPES (ADTs).
The use of abstract data types makes the design of the algorithm more general, and allows us to concentrate on the algorithm at hand without getting bogged down in implementation details. After the algorithms have been designed, the actual data types will need to be implemented, along with the algorithms. Recently, procedural languages have been extended to support the definition of new data types and provide facilities for data abstraction.
THE OBJECT-ORIENTED PARADIGM. The object- oriented paradigm retains much of the characteristics of the procedural paradigm, since procedures are still the primary form for composing computations. However, rather than operate on
abstract values, programs in the object-oriented paradigm operate on objects. An object is very similar to an abstract data type and contains data as well as procedures.
There are three primary characteristics of the object-oriented paradigm. We have already described the first, ENCAPSULATION, the mechanism for enforcing data abstraction. The second characteristic is INHERITANCE. Inheritance allows new objects to be created from existing, more general ones. The new object becomes a specialized version of the general object. New objects need only provide the methods or data that differ because of the specialization. When an object is created (or derived) from another object, it is said to inherit the methods and data of the parent object, and includes any new representations and new or revised methods added to it.
The third and final characteristic of object-oriented programming is POLYMORPHISM. Polymorphism allows many different types of objects to perform the same operation by responding to the same message. For example, we may have a collection of objects which can all perform a sort operation. However, we do not know what types of objects will be created until run-time. Object-oriented languages contain mechanisms for ensuring that each sort message is sent to the right object.
Encapsulation, inheritance, and polymorphism are considered the fundamental characteristics of object-oriented programming and all object-oriented languages must provide these characteristics in some way. Not surprisingly, languages support these characteristics in very different ways. Smalltalk, C++, Objective-C, and Lisp with CLOS (the Common Lisp Object System) are all examples of object-oriented languages, and each provides support for encapsulation, inheritance, and polymorphism.
Constructing an object-oriented program involves determining the objects that are needed to solve the problem. The objects are then used to construct computations that define the behavior of the software system. Message passing is the fundamental interaction mechanism among objects. Messages (from other objects or programs) are sent to objects to inform them to perform one of their operations.
Objects are responsible for maintaining the state of their data. Only the object may modify its internal data. Objects may themselves be implemented via other
sub-objects. Implementing an object involves a recursive process of breaking it into sub-objects until at some level the objects and methods defined on them are primitives. At this point, the methods and data consist of elements that can be implemented using the basic constructs provided by the programming language.
One of the most important aspects of the object-oriented paradigm is how it changes our way of thinking about software systems. Systems are thought of as consisting of individual entities that are responsible for carrying out their own operations. Each object is conceived and implemented as self-contained. Such a model facilitates software design (and later implementation) because objects often model conceptual real-world entities. Designing systems using the object-oriented paradigm results in software systems that behave and appear more like their real-life counterparts.
2. The Object-Oriented Characteristics of C++
ENCAPSULATION in C++. C++ extends C with a facility for defining new data types. A class is like a C struct, but contains data as well as methods. In addition, C++ provides different levels of access to the members of a class in order to control how the members of a class can be manipulated from outside the class.
Recall that the importance of data abstraction is to hide the implementation details of a data object from the user. The user only accesses the object through its PUBLIC INTERFACE. A C++ class consists of a public and private part. The public part provides the interface to the users of the class, while the private part can only be used by the functions that make up the class.
C++ provides keywords to indicate which members of a class are hidden and which are part of its public interface. The members of the hidden implementation are marked in sections beginning with the keyword private. The public interface part of the class follows the keyword public. By default, the declarations within a class are private, meaning that only the member functions (and friends) of the class have access to them.
A class definition does not allocate any memory. Memory is allocated when an array object is created through a variable declaration. Constructors and destructors provide the initialization and clean up of an object. When an object is declared, the constructor is called to initialize the memory used by the object. The destructor performs any clean-up for the object when the object goes out of scope and is destroyed.
Note that we didn't really hide the implementation details from the user. C++ does not provide a way to completely exclude all of the details of the underlying implementation, since the private part of the class must be included with the class definition it is useful to relax the access to variables within a class, particularly under inheritance. Often derived classes need easy access to the private members of their parent classes. C++ defines the keyword protected for this purpose. Protected members can be accessed by the member functions of a class as well as by member functions of derived classes. However, like private members, protected members cannot be accessed by user programs.
One final note about objects. Recall that message passing is the fundamental means for communication among objects. When we write i < a2.Size() we are effectively sending a message to the a2 array object to determine the size of the array and return it. In actuality, no message is really sent. C++ emulates message passing through the use of function calls. The compiler ensures us that the correct function will be called for the desired object. So, in C++ you can think of message passing as function calls.
Object-orientation has become a buzzword with many meanings. It is a design methodology, a paradigm (a way of thinking about problems and finding solutions), and a form of programming. As a design methodology, we can use object-oriented techniques to design software systems. But it is more than a design methodology, it is a whole new way of thinking about problems. Object-oriented design allows us to think about the actual real-world entities of the problem we are attempting to provide a solution for. Beginning the design with concepts from the real- world problem domain allows the same concepts to be carried over to implementation, making the
design and implementation cycle more seamless.
Once a design has been conceived, a programming language can be chosen for implementation. By factoring out the inheritance relationships from the object hierarchies discovered during design, one can even implement the system in a traditional, non- object-oriented language. However, using an object-oriented language, such as C++, makes it easier to realize the design into an implementation because the inherent relationships among objects can be directly supported in the language.
Languages such as C++ are considered hybrid languages because they are multi-paradigm languages. C++ is an object- oriented extension of C and can be used as a procedural language or as an object-oriented language. In this issue, we continue our tour of the object-oriented features of C++.
3. The Object-Oriented Features of C++
INHERITANCE in C++. One of the major strengths of any object-oriented programming language is the ability to build other classes from existing classes, thereby reusing code. Inheritance allows existing types to be extended to an associated collection of sub-types.
Recall that one of the key actions of object-oriented design is to identify real-world entities and the relationships among them. When a software system is designed, a variety of objects arise, which may be related in one way or another. Some classes may not be related at all. Many times it makes sense to organize the object classes into an inheritance hierarchy. Organizing a set of classes into a class hierarchy requires that we understand the relationships among the classes in detail. Not all class relationships dictate that inheritance be used.
C++ provides three forms of inheritance: public, private, and protected. These different forms are used for different relation- ships between objects. To illustrate these different types of inheritance, let's look at several different class relationships.
The first relationship is the IS-A relationship. This type of relationship represents
a specialization between types or classes. IS-A inheritance holds for two classes if the objects described by one class belongs to the set of objects described by the other more general class. The IS-A relationship is the traditional form of inheritance called subtyping. The subtype is a specialization of some more general type known as the supertype. In C++, the supertype is called the base class and the subtype the derived class.
To implement the IS-A relationship in C++ we use public inheritance. When public inheritance is used the public parts of the base class become public in the derived class and the protected parts of the base class become protected in the derived class.
To implement the HAS-A relationship in C++ we use either composition or private inheritance. For example, a stack can be implemented using an array. We can either use the stack as a data member (composition) or derive the stack class from the array class using private inheritance.
It is also possible to use inheritance to achieve a containership relationship between two classes. Private inheritance is used when the inheritance is not part of the interface; the base class is an implementation detail. Under private inheritance, the public and protected parts of the base class become part of the private part of the derived class. Users of the derived class cannot access any of the base class interface. However, member functions of the derived class are free to use the public and private parts of the base class. When used this way, users cannot write code that depends on the inheritance. This is a powerful way of preserving your ability to change the implementation to a different base class.
One other form of inheritance, which is very rarely used is protected inheritance. Protected inheritance is also used to implement HAS-A relationships. When protected inheritance is used, the public and protected parts of the base class become protected in the derived class. So, you may wish to use protected inheritance when the inheritance is part of the interface to derived classes, but not part of the interface to the users. A protected base class is almost like a private base class, except the interface is known to derived classes.
It is best to use composition where possible. In cases where you must override functions in a base class then by all means use inheritance. Only use public inheritance if your derived class is indeed a specialization of the base class, otherwise, private inheritance should be used. Needlessly using inheritance makes your system harder to understand.
In summary, a class specifies two interfaces: one to the users of the class (the public interface) and another to implementers of derived classes (the union of public and protected parts). Inheritance works almost identically. When the inheritance is public, the public interface of the base class becomes part of the public interface to users of the derived class. When the inheritance is protected, the public and protected parts of the base class are accessible to the member functions (the implementation) of the derived classes, but not to general users of the derived classes. Finally, when inheritance is private, the public and protected parts of the base class are only accessible to the implementer of the class, but not to users or derived classes.
POL YMORPHISM in C++. Polymorphism is the last of the three fundamental primitives of object-oriented programming and the most important. Together with inheritance, polymorphism brings the most power, in terms of run-time flexibility, to object-oriented programming. Polymorphism, which means many forms, provides a generic software interface so that a collection of different types of objects may be manipulated uniformly. C++ provides three different types of polymorphism: virtual functions, function name overloading, and operator overloading.
The virtual function mechanism can only be invoked through the use of a base class reference or pointer.
Recall that a base class pointer can point to an object of the base type or an object of any type that is derived from the base class.
Virtual functions are also used to implement the logic gate hierarchy .The class gate is an abstract base class at the root of the inheritance hierarchy. A class is considered abstract when some of its virtual member functions do not have an implementation. These functions are assigned to be zero in the class definition.Derived classes must provide implementations for them.
Another form of polymorphism found in C++ is function overloading. A function is said to be overloaded when it is declared more than once in a program. Overloading allows a set of functions that perform a similar operation to be collected under the same name. When there are several declarations of the same function, the compiler determines which function should be called by examining the return type and argument signature of the function call.
When we define new data types, it is often useful to define standard operations that are found in similar types. For example, a complex type also has addition and subtraction defined for it. We can use operator overloading so that the addition (`+') and subtraction (`-') operators work for complex objects just as they do for ints and floats.
Operators are defined in much the same was as normal C++ functions and can be members or non-members of a class. Operators take one or two arguments and are called unary and binary operators accordingly. In C++, a member operator function is defined like an ordinary member function, but the name is prefixed with the keyword operator.
C++ places a number of restrictions on operator overloading. Only the pre-defined set of C++ operators may be overloaded. It is illegal to define a new operator and then overload it. You cannot turn a unary operator into a binary operator or vice versa. Also, the following operators cannot be overloaded: scope operator (`::'), member object selection operator (`.*'), class object selector operator (`.'), and the arithmetic if operator (`?:').
In the last two issues of ObjectiveViewPoint we have looked at how C++ supports the object-oriented paradigm.
外文文献译文
面向对象和C++
C++是目前所使用的众多编程语言中的一种。为什么会有那么多的语言？为什么总会有新的语言不断出现？编程语言可以帮助程序员方便实现从设计到实现。第一个编程语言对基本的机器结构有很大的依赖性。这时程序的细节很笨重。只有硬件设计师了解如何在其他成分之外建立计算机体系，语言设计者同样认识到程序可以在一个高水平的环境编写，因而是程序员可以不必了解机器的细节。
为什么有这么多高水平的编程语言？有很多语言可以访问大型数据库，格式化金融报告，控制机器人在工厂工作，处理机件，控制卫星实时模拟核反应堆，预测变化的大气层状况，下棋和绘制电路图。每一个问题都需要不同的数据结构和算法。程序语言作为一种工具帮助我们解决这些问题。然而，并不是一种程序语言可以最好的解决所有问题。新的语言被开发来更好的解决一类特定的问题。其他语言可以用来解决不同的问题领域和多方面的用途。每个程序语言固定一个特定的程序体系或设计程序原理。使用多种多样的语言建立不同的设计方案。这些方案被叫做程序范例，帮助我们思考问题，规范解决。
1.通过范例设计软件
当设计一个小的计算机程序或大的软件系统是，我们要思考问题的解决模式。怎样去设计一个模式？程序范例提供了许多不同的方法去设计和思考软件系统。一个范例可以被认为是一个模式或者一个框架来设计和描述软件结构。这个模式帮助我们去思考和规范解决。我们可以选择一种语言，使用范例独立的完成。当所选择的语言提供的结构和机制符合范例时，就很容易完成。一般来说，几种语言可能属于同一种范例。因此，一种范例可以被看作一种语言的类。
一种语言不仅要符合一种范例，而且能够使用多种范例提供的特性和特征。混合语言，如C++，综合了两到三种范例。C++包括了命令和程序范例的特性，例如，其前身—C,和面向对象范例。
命令范例：命令范例的特性是计算机的抽象模型和巨大的内存存储。这是计
算机体系的von Neumann模型。计算命令，由一系列的命令组成，以代码形式存储。命令可以使机器找到解决方法，使用指定命令改变存储，变量读取，算术和逻辑表达式，条件分枝控制执行流。
程序范例：它包括了命令范例，还有对概念命令和表达的抽象机制。参数，即存储的一部分，被引进在范例中。还包括重复，选择等特征。许多主流程序还是这种语言。程序范例在程序设计中首次引进了抽象的概念。抽象可以把动作和结果隔离。过程是抽象的表格，完成一些任务或功能。其他部分调用时，只是正确有效的执行，但不清楚过程的执行。
程序范例和ADT：数据抽象使一个数据对象的行为和它的描述或执行相分离。用户无法看到数据的基本操作，执行可以方便的更改而不影响程序的运行。
当我们设计一个算法时，需要一个特定的数据类型执行算法的操作。如果可以定义变量的数据类型，而不影响到实际数据类型的运行，就可以很容易的制订出算法。通过定义数据的用法和操作，假定可以选择任何一种运行，这种定义就叫做抽象数据类型。抽象数据类型的使用使得算法的设计得到更大的推广，使得我们在算法设计时，注重了算法的全面，而不会拘泥于运行的细节。当算法设计完成时，实际的数据类型被执行。近来，程序语言扩展到支持新的数据类型的定义和提供便利给数据抽象。
面向对象的范例：它仍然保留了许多程序范例的特征，过程仍然是计算的主要形式。但是，程序不仅仅是抽象值的运算，在面向对象范例种还有对对象的运算。对象同抽象数据类型很相似，联系着数据和运算。
面向对象范例具有三种主要特性，第一种，压缩，其机制是为了实施数据抽象。第二种，继承。继承允许从已存在的对象中创建新的对象。这个新创建的对象是原对象的具体说明。新对象的不同在于只需要提供方法或数据。当一个对象从另一个对象中被创建或取得时，就说新对象继承了它父对象的方法和数据，并增加了一些新的描述和说明。面向对象的第三种特性是多态。多态可以使不同类型的的对象对相同的信息执行相同的操作。例如，我们有一部分对象它们可以执行一类操作，但是只有在运行时我们才知道对象的类型。面向对象语言包含的机制确保了每一类信息传递给正确的对象。
压缩，继承和多态被认为是面向对象程序的基本特征，所有的面向对象程序
语言必须提供这些特征。一般来说，语言通过不同的途径支持这些特征的实现。Smalltalk, C++, Objective-C, 和Lisp with CLOS (the Common Lisp Object System)这些程序语言都是面向对象语言的例子，它们都可以提供对压缩，继承和多态的支持。
构建一个面向对象的程序需要决定解决问题所需的对象。这些对象被用来构建计算，定义软件系统的操作运行。信息的传递是对象间最基本的相互作用机制。信息（从其他的对象或程序）传递给对象，以便通知对象运行下一个操作。对象需要负责维护它所相关的数据的状态。只有对象本身才可以改变它内部的数据值。对象本身可以完全的调用它的子对象。一个对象的执行是一个循环递归的过程，当定义这个对象和方法的初始值是，可以跳出这个循环递归的过程。这时，这个方法和数据所组成的元素可以使用程序语言所提供的基本的构造函数。
学习面向对象范例最重要的一点是如何改变我们思考建造软件体系的思路。系统被认为是由多个单一独立的个体组成，其中每个个体只负责对其自身的操作的运行。每一个对象的设置和运行都是自身所包含的。由于对象常常模仿真实世界的个体的概念，因而这样的一个模型推动了软件方面的设计（以及后来的实行）。设计一个系统使用面向对象的范例，从而使得系统的操作和运行更类似于真实世界中所对应的真实个体。
2.面向对象的特征
压缩：C++继承了C的发展，并且定义的新的方便的数据类型。一个类就像C的结构，但不同的是同时包括了数据和方法。除此之外，C++还提供了类中各个成员访问权限的不同，以此方便的控制即使是在不同的类，也可以访问类中的成员。
重复的调用一个抽象的数据可以对用户隐藏对一个数据对象的操作细节。用户只可以通过一个公共的接口来访问这个对象。一个C++的类既包括共有的部分，又包括私有的部分。公有的部分提供给用户关于这个类的接口，私有的部分只有构造这个类的函数才可以访问。
C++提供了关键字来说明类中哪些成员是不可见的，哪些部分是其公共接口。不可见的成员在其定义的部分标明了关键字private。公共的接口部分标有关
键字public。当一个类是私有的类时，意味着只有这个类的函数或友元可以使用它。
一个类的定义并不分配内存。当一个数据对象被创建并且具有变量声明时才分配内存。构造函数和析构函数提供了对象的初始化和释放功能。当一个对象被声明时，它的构造函数初始化其在内存的值。当对象离开它所在的范围时，调用析构函数释放对象。
我们不可能对用户完全的隐藏操作的细节。C++无法提供一个使所有细节完全排除在基本操作之外的方法，因此一个类的私有部分必须这个类的定义，从而有效的访问这个类的变量，并可以继承。建造一个类可以使它方便的访问它父类的私有成员。C++定义了关键字protected来完成继承的实现。保护成员既可以被类的成员函数访问，也可以被派生类的成员函数访问。和私有成员相同的一点，保护成员不可以被用户程序访问。
对象所需要注意的最后一点，信息的重复传递时对象间交流的基本功能。例如一个语句i < a2.Size()，我们可以有效的把信息传给a2的对象，以确定组的大小并返回其值。实际上，这里并没有真的传递信息。C++通过调用函数模拟信息的传递。编译器确保对所需要的对象调用正确的函数，因此，在C++中，可以把信息的传递当作函数的调用。
当设计了一种方案，一种程序语言就可以被选择执行。可以在设计的过程中找到对象间的继承关系，甚至可以使用传统的，非面向对象的语言设计系统。但是，使用面向对象语言，如C++，由于语言支持对象间的继承关系，从而可以更方便的了解设计执行。
C++语言是混合型的语言，它属于多范例的语言。C++可以认为是C语言的扩展的过程语言或面向对象语言。
3. C++面向对象的特性
C++继承：任何面向对象程序语言其最主要的作用就是可以从原有的类中创建新的类，从而可以再次使用代码。继承可以从与原有的类型扩展到派生类型。
面向对象设计的一个主要操作就是要确认真实世界的个体以及各个个体之间的联系。当设计一个软件系统时，需要建立一系列的对象，并且需要互相关联
的一系列对象。有些类之间可能不是完全的相关。大部分的类之间可以归纳为继承的关系。将一系列的类归为一个类的层次需要明白各个类之间的关系和他们之间的细节。但不是所有的类之间都可以建立继承的关系。
C++提供了三种方式的继承：公有继承，私有继承，保护继承。这些不同的方式应用在不同的对象间关系。
第一种关系是IS-A关系。这种关系是类型与类型，类与类之间特有的关系。IS-A继承指两个类，其中一个类描述了对对象的说明，对对象的设置说明由另一个类来说明。IS-A的关系是传统的继承关系，也就是派生类型。派生类型是一些基本类型即父类型的专门化，在C++中，超级类型就是基类，派生类型就是派生类。
在C++中执行IS-A关系需要使用公有继承。在基类中的公共部分使用公有继承，在派生类中也是公有的部分，在基类中的保护部分使用公有继承，在派生类中也变成保护的部分
有时在两个对象之间的关系也许是包含关系，也可以是部分整体之间的关系。不是所有对象它都是其他对象的一个专门说明和继承，可能这些对象有些是其他对象的一部分或是包含在其他的对象中。
在C++中使用HAS-A关系可以使用成员或是私有继承。例如，一个堆栈可以被当作一个数组使用。我们可以使用堆栈作为一个数据成员,或者使用私有继承，从数组类中继承堆栈类。
可以在两个类之间使用继承创建一个互相包含的关系。私有继承只有在不是接口的部分可以被使用，基类是一个细节的执行。在私有继承的情况下，原来基类中的公有部分和保护部分，在派生类中都变为私有部分。派生类的使用者不可以访问基类中的接口。但是派生类中的成员函数可以自由的访问或调用基类中的公共部分和私有部分。当这样使用基类中的成员时，用户不可以只依靠继承来编写代码。这是一个修改为不同的基类的运行。继承的另一种方式，也是很少使用的一种方式就是保护继承。保护继承也是一种可以使用HAS-A关系的继承。当使用保护继承时，在基类中的公有部分和保护部分，在派生类中就都变为保护部分。当继承是接口的部分时，派生类要使用保护继承，但是不是接口的所有部分都可以被用户使用。一个保护的基类类似于一个私有的基类，不同在于继承的派
生类可以知道接口部分。
如果可以的话，最好使用数据成员。这时当你必须重复使用基类中的函数时，可以使用其继承。如果你所有的派生类是基类的一个说明构造时，只有使用公有继承，否则，要使用私有继承。当在不必要时使用继承，会使系统更加难以理解。
总之，一个类有两个主要的接口：一个是给用户所使用的（公共接口），另一个派生类所使用（公有部分和保护部分的联合）。继承的部分是基本相同的。在基类中的公共接口使用公有继承，在派生类中队用户也是公有接口。在基类中的公共部分和保护部分使用保护继承，在派生类中可以使用成员函数，但并不对派生类的所有用户。最后，当在基类中的公共部分和保护部分使用私有继承，基类可以调用，但用户和派生类不可以使用。
C++多态：多态是面向对象程序的三个特性中最重要的部分。多态，和继承一起，对面向对象程序有很大的用途。多态，就是说有多个形式，提供一个基本的软件接口以建立不同类型的对象操作的统一的方式。C++提供了三种类型的多态：虚函数，函数重载和运算符重载。
虚函数可以使继承的同层相关的对象用同一种方式操作。当所有的函数传递同样的信息值时，虚函数的机制确保在动态运行时了调用正确的函数。一个类的普通的成员函数是静态的单一的过程，在编译时调用。它只有一个对成员函数的说明使用于类中所有的例子。
当定义一个成员函数时，在它前面加上关键字virtual，实际过程的调用依赖于对象实例的类型，通过这样来判断如何调用。这是一个动态的约束。静态方式的束定也叫做早期束定。
虚函数机制可以通过一个基类的参数或指针调用。一个基类的指针可以指向一个基本类型的对象或任何从基类派生出的类型的对象。虚函数也可以用在逻辑的运算上。一个类是抽象的类当这个类是继承的根节点时。一个类当它只有虚函数的定义而没有实现时是抽象类。这些函数在类定义时被赋予0值。派生类必须给出他们的实现。
另一个多态的形式是函数重载。当一个函数被使用在多个程序时就是重载。重载允许在同样的名称下执行一系列相似的功能。当有相同函数时，编译器通过检查它的返回值和参数决定哪个被调用。
当我们定义新的数据类型时，需要定义相似类型的标准的操作。一个复数的类型要有加减的运算。我们可以使用运算符重载加减操作就像整形和浮点型数据。运算符的定义和C++函数的定义相似，可以作为类的成员或非成员。运算符有一个或两个参数分别叫做单目或双目运算符。在C++中，一个运算符函数的定义就像一个成员函数的定义，在其名字的前面加上关键字operator。C++在运算符的重载上有一些限制，只有先定义运算符的操作才可以被重载，只定义了运算符就重载是错误的。你不能把单目运算符返回到双目运算或多目运算中。同时，范围运算(`::'),成员运算(`.*'),类运算(`.'),选择运算(`?:')不能重载。
在这后两点的面向对象分析中，我们可以看到C++很好的支持了面向对象的范例。
英文论文及中文翻译
International Journal of Minerals, Metallurgy and Materials Volume 17, Number 4, August 2010, Page 500 DOI: 10.1007/s12613-010-0348-y Corresponding author: Zhuan Li E-mail: li_zhuan@https://www.wendangku.net/doc/817569210.html, ? University of Science and Technology Beijing and Springer-Verlag Berlin Heidelberg 2010 Preparation and properties of C/C-SiC brake composites fabricated by warm compacted-in situ reaction Zhuan Li, Peng Xiao, and Xiang Xiong State Key Laboratory of Powder Metallurgy, Central South University, Changsha 410083, China (Received: 12 August 2009; revised: 28 August 2009; accepted: 2 September 2009) Abstract: Carbon fibre reinforced carbon and silicon carbide dual matrix composites (C/C-SiC) were fabricated by the warm compacted-in situ reaction. The microstructure, mechanical properties, tribological properties, and wear mechanism of C/C-SiC composites at different brake speeds were investigated. The results indicate that the composites are composed of 58wt% C, 37wt% SiC, and 5wt% Si. The density and open porosity are 2.0 g·cm–3 and 10%, respectively. The C/C-SiC brake composites exhibit good mechanical properties. The flexural strength can reach up to 160 MPa, and the impact strength can reach 2.5 kJ·m–2. The C/C-SiC brake composites show excellent tribological performances. The friction coefficient is between 0.57 and 0.67 at the brake speeds from 8 to 24 m·s?1. The brake is stable, and the wear rate is less than 2.02×10?6 cm3·J?1. These results show that the C/C-SiC brake composites are the promising candidates for advanced brake and clutch systems. Keywords: C/C-SiC; ceramic matrix composites; tribological properties; microstructure [This work was financially supported by the National High-Tech Research and Development Program of China (No.2006AA03Z560) and the Graduate Degree Thesis Innovation Foundation of Central South University (No.2008yb019).] 温压-原位反应法制备C / C-SiC刹车复合材料的工艺和性能 李专，肖鹏，熊翔 粉末冶金国家重点实验室，中南大学，湖南长沙410083，中国（收稿日期：2009年8月12日修订：2009年8月28日;接受日期：2009年9月2日） 摘要：采用温压?原位反应法制备炭纤维增强炭和碳化硅双基体(C/C-SiC)复合材
关于力的外文文献翻译、中英文翻译、外文翻译
五、外文资料翻译 Stress and Strain 1.Introduction to Mechanics of Materials Mechanics of materials is a branch of applied mechanics that deals with the behavior of solid bodies subjected to various types of loading. It is a field of study that i s known by a variety of names, including “strength of materials” and “mechanics of deformable bodies”. The solid bodies considered in this book include axially-loaded bars, shafts, beams, and columns, as well as structures that are assemblies of these components. Usually the objective of our analysis will be the determination of the stresses, strains, and deformations produced by the loads; if these quantities can be found for all values of load up to the failure load, then we will have obtained a complete picture of the mechanics behavior of the body. Theoretical analyses and experimental results have equally important roles in the study of mechanics of materials . On many occasion we will make logical derivations to obtain formulas and equations for predicting mechanics behavior, but at the same time we must recognize that these formulas cannot be used in a realistic way unless certain properties of the been made in the laboratory. Also , many problems of importance in engineering cannot be handled efficiently by theoretical means, and experimental measurements become a practical necessity. The historical development of mechanics of materials is a fascinating blend of both theory and experiment, with experiments pointing the way to useful results in some instances and with theory doing so in others①. Such famous men as Leonardo da Vinci(1452-1519) and Galileo Galilei (1564-1642) made experiments to adequate to determine the strength of wires , bars , and beams , although they did not develop any adequate theo ries (by today’s standards ) to explain their test results . By contrast , the famous mathematician Leonhard Euler(1707-1783) developed the mathematical theory any of columns and calculated the critical load of a column in 1744 , long before any experimental evidence existed to show the significance of his results ②. Thus , Euler’s theoretical results remained unused for many years, although today they form the basis of column theory. The importance of combining theoretical derivations with experimentally determined properties of materials will be evident theoretical derivations with experimentally determined properties of materials will be evident as we proceed with
平面设计中英文对照外文翻译文献
(文档含英文原文和中文翻译) 中英文翻译 平面设计 任何时期平面设计可以参照一些艺术和专业学科侧重于视觉传达和介绍。采用多种方式相结合，创造和符号，图像和语句创建一个代表性的想法和信息。平面设计师可以使用印刷，视觉艺术和排版技术产生的最终结果。平面设计常常提到的进程，其中沟通是创造和产品设计。 共同使用的平面设计包括杂志，广告，产品包装和网页设计。例如，可能包括产品包装的标志或其他艺术作品，举办文字和纯粹的设计元素，如形状和颜色统一件。组成的一个最重要的特点，尤其是平面设计在使用前现有材料或不同的元素。 平面设计涵盖了人类历史上诸多领域，在此漫长的历史和在相对最近爆炸视觉传达中的第20和21世纪，人们有时是模糊的区别和重叠的广告艺术，平面设计和美术。毕竟，他们有着许多相同的内容，理论，原则，做法和语言，有时同样的客人或客户。广告艺术的最终目标是出售的商品和服务。在平面
设计，“其实质是使以信息，形成以思想，言论和感觉的经验”。 在唐朝（ 618-906 ）之间的第4和第7世纪的木块被切断打印纺织品和后重现佛典。阿藏印在868是已知最早的印刷书籍。 在19世纪后期欧洲，尤其是在英国，平面设计开始以独立的运动从美术中分离出来。蒙德里安称为父亲的图形设计。他是一个很好的艺术家，但是他在现代广告中利用现代电网系统在广告、印刷和网络布局网格。 于1849年，在大不列颠亨利科尔成为的主要力量之一在设计教育界，该国政府通告设计在杂志设计和制造的重要性。他组织了大型的展览作为庆祝现代工业技术和维多利亚式的设计。 从1892年至1896年威廉?莫里斯凯尔姆斯科特出版社出版的书籍的一些最重要的平面设计产品和工艺美术运动，并提出了一个非常赚钱的商机就是出版伟大文本论的图书并以高价出售给富人。莫里斯证明了市场的存在使平面设计在他们自己拥有的权利，并帮助开拓者从生产和美术分离设计。这历史相对论是，然而，重要的，因为它为第一次重大的反应对于十九世纪的陈旧的平面设计。莫里斯的工作，以及与其他私营新闻运动，直接影响新艺术风格和间接负责20世纪初非专业性平面设计的事态发展。 谁创造了最初的“平面设计”似乎存在争议。这被归因于英国的设计师和大学教授Richard Guyatt，但另一消息来源于20世纪初美国图书设计师William Addison Dwiggins。 伦敦地铁的标志设计是爱德华约翰斯顿于1916年设计的一个经典的现代而且使用了系统字体设计。 在20世纪20年代，苏联的建构主义应用于“智能生产”在不同领域的生产。个性化的运动艺术在俄罗斯大革命是没有价值的，从而走向以创造物体的功利为目的。他们设计的建筑、剧院集、海报、面料、服装、家具、徽标、菜单等。 Jan Tschichold 在他的1928年书中编纂了新的现代印刷原则，他后来否认他在这本书的法西斯主义哲学主张，但它仍然是非常有影响力。 Tschichold ，包豪斯印刷专家如赫伯特拜耳和拉斯洛莫霍伊一纳吉，和El Lissitzky 是平面设计之父都被我们今天所知。 他们首创的生产技术和文体设备，主要用于整个二十世纪。随后的几年看到平面设计在现代风格获得广泛的接受和应用。第二次世界大战结束后，美国经济的建立更需要平面设计，主要是广告和包装等。移居国外的德国包豪斯设计学院于1937年到芝加哥带来了“大规模生产”极简到美国;引发野火的“现代”建筑和设计。值得注意的名称世纪中叶现代设计包括阿德里安Frutiger ，设计师和Frutiger字体大学;保兰德，从20世纪30年代后期，直到他去世于1996年，采取的原则和适用包豪斯他们受欢迎的广告和标志设计，帮助创造一个独特的办法，美国的欧洲简约而成为一个主要的先驱。平面设计称为企业形象;约瑟夫米勒，罗克曼，设计的海报严重尚未获取1950年代和1960年代时代典型。 从道路标志到技术图表，从备忘录到参考手册，增强了平面设计的知识转让。可读性增强了文字的视觉效果。 设计还可以通过理念或有效的视觉传播帮助销售产品。将它应用到产品和公司识别系统的要素像标志、颜色和文字。连同这些被定义为品牌。品牌已日益成为重要的提供的服务范围，许多平面设计师，企业形象和条件往往是同时交替使用。
英文文献及中文翻译
毕业设计说明书 英文文献及中文翻译 学院：专 2011年6月 电子与计算机科学技术软件工程
https://www.wendangku.net/doc/817569210.html, Overview https://www.wendangku.net/doc/817569210.html, is a unified Web development model that includes the services necessary for you to build enterprise-class Web applications with a minimum of https://www.wendangku.net/doc/817569210.html, is part of https://www.wendangku.net/doc/817569210.html, Framework,and when coding https://www.wendangku.net/doc/817569210.html, applications you have access to classes in https://www.wendangku.net/doc/817569210.html, Framework.You can code your applications in any language compatible with the common language runtime(CLR), including Microsoft Visual Basic and C#.These languages enable you to develop https://www.wendangku.net/doc/817569210.html, applications that benefit from the common language runtime,type safety, inheritance,and so on. If you want to try https://www.wendangku.net/doc/817569210.html,,you can install Visual Web Developer Express using the Microsoft Web Platform Installer,which is a free tool that makes it simple to download,install,and service components of the Microsoft Web Platform.These components include Visual Web Developer Express,Internet Information Services (IIS),SQL Server Express,and https://www.wendangku.net/doc/817569210.html, Framework.All of these are tools that you use to create https://www.wendangku.net/doc/817569210.html, Web applications.You can also use the Microsoft Web Platform Installer to install open-source https://www.wendangku.net/doc/817569210.html, and PHP Web applications. Visual Web Developer Visual Web Developer is a full-featured development environment for creating https://www.wendangku.net/doc/817569210.html, Web applications.Visual Web Developer provides an ideal environment in which to build Web sites and then publish them to a hosting https://www.wendangku.net/doc/817569210.html,ing the development tools in Visual Web Developer,you can develop https://www.wendangku.net/doc/817569210.html, Web pages on your own computer.Visual Web Developer includes a local Web server that provides all the features you need to test and debug https://www.wendangku.net/doc/817569210.html, Web pages,without requiring Internet Information Services(IIS)to be installed. Visual Web Developer provides an ideal environment in which to build Web sites and then publish them to a hosting https://www.wendangku.net/doc/817569210.html,ing the development tools in Visual Web Developer,you can develop https://www.wendangku.net/doc/817569210.html, Web pages on your own computer.
10kV小区供配电英文文献及中文翻译
在广州甚至广东的住宅小区电气设计中,一般都会涉及到小区的高低压供配电系统的设计.如10kV高压配电系统图,低压配电系统图等等图纸一大堆.然而在真正实施过程中,供电部门(尤其是供电公司指定的所谓电力设计小公司)根本将这些图纸作为一回事,按其电脑里原有的电子档图纸将数据稍作改动以及断路器按其所好换个厂家名称便美其名曰设计(可笑不?),拿出来的图纸根本无法满足电气设计的设计意图,致使严重存在以下问题:(也不知道是职业道德问题还是根本一窍不通) 1.跟原设计的电气系统货不对板,存在与低压开关柜后出线回路严重冲突,对实际施工造成严重阻碍,经常要求设计单位改动原有电气系统图才能满足它的要求(垄断的没话说). 2.对消防负荷和非消防负荷的供电(主要在高层建筑里)应严格分回路(从母线段)都不清楚,将消防负荷和非消防负荷按一个回路出线(尤其是将电梯和消防电梯,地下室的动力合在一起等等,有的甚至将楼顶消防风机和梯间照明合在一个回路,以一个表计量). 3.系统接地保护接地型式由原设计的TN-S系统竟曲解成"TN-S-C-S"系统(室内的还需要做TN-C,好玩吧?),严格的按照所谓的"三相四线制"再做重复接地来实施,导致后续施工中存在重复浪费资源以及安全隐患等等问题.. ............................(违反建筑电气设计规范等等问题实在不好意思一一例举,给那帮人留点混饭吃的面子算了) 总之吧,在通过图纸审查后的电气设计图纸在这帮人的眼里根本不知何物,经常是完工后的高低压供配电系统已是面目全非了,能有百分之五十的保留已经是谢天谢地了. 所以.我觉得:住宅建筑电气设计,让供电部门走!大不了留点位置,让他供几个必需回路的电,爱怎么折腾让他自个怎么折腾去.. Guangzhou, Guangdong, even in the electrical design of residential quarters, generally involving high-low cell power supply system design. 10kV power distribution systems, such as maps, drawings, etc. low-voltage distribution system map a lot. But in the real implementation of the process, the power sector (especially the so-called power supply design company appointed a small company) did these drawings for one thing, according to computer drawings of the original electronic file data to make a little change, and circuit breakers by their the name of another manufacturer will be sounding good design (ridiculously?), drawing out the design simply can not meet the electrical design intent, resulting in a serious following problems: (do not know or not know nothing about ethical issues) 1. With the original design of the electrical system not meeting board, the existence and low voltage switchgear circuit after qualifying serious conflicts seriously hinder the actual construction, often require changes to the original design unit plans to meet its electrical system requirements (monopoly impress ). 2. On the fire load and fire load of non-supply (mainly in high-rise building in) should be strictly sub-loop (from the bus segment) are not clear, the fire load and fire load of non-qualifying press of a circuit (especially the elevator and fire elevator, basement, etc.
中文和英文简历和专业英语材料翻译
韶关学院 期末考核报告 科目：专业英语 学生姓名： 学号： 同组人： 院系： 专业班级： 考核时间：2012年10月9日—2012年11月1 日评阅教师： 评分：
第1章英文阅读材料翻译 (1) 第2章中文摘要翻译英文 (3) 第3章中文简历和英文简历 (4) 第4章课程学习体会和建议 (6) 参考文献 (7)
第1章英文阅读材料翻译 Mechanization and Automation Processes of mechanization have been developing and becoming more complex ever since the beginning of the Industrial Revolution at the end of the 18th century. The current developments of automatic processes are, however, different from the old ones. The “automation” of the 20th century is distinct from the mechanization of the 18th and 19th centuries inasmuch as mechanization was applied to individual operations, wherea s “automation” is concerned with the operation and control of a complete producing unit. And in many, though not all, instances the element of control is so great that whereas mechanization displaces muscle, “automation”displaces brain as well. The distinction between the mechanization of the past and what is happening now is, however, not a sharp one. At one extreme we have the electronic computer with its quite remarkable capacity for discrimination and control, while at the other end of the scale are “ transfer machines” , as they are now called, which may be as simple as a conveyor belt to another. An automatic mechanism is one which has a capacity for self-regulation; that is, it can regulate or control the system or process without the need for constant human attention or adjustment. Now people often talk about “feedback” as begin an essential factor of the new industrial techniques, upon which is base an automatic self-regulating system and by virtue of which any deviation in the system from desired condition can be detected, measured, reported and corrected. when “feedback” is applied to the process by which a large digital computer runs at the immense speed through a long series of sums, constantly rejecting the answers until it finds one to fit a complex set of facts which have been put to it, it is perhaps different in degree from what we have previously been accustomed to machines. But “feedback”, as such, is a familiar mechanical conception. The old-fashioned steam engine was fitted with a centrifugal governor, two balls on levers spinning round and round an upright shaft. If the steam pressure rose and the engine started to go too fast, the increased speed of the spinning governor caused it to rise up the vertical rod and shut down a valve. This cut off some of the steam and thus the engine brought itself back to its proper speed. The mechanization, which was introduced with the Industrial Revolution, because it was limited to individual processes, required the employment of human labor to control each machine as well as to load and unload materials and transfer them from one place to another. Only in a few instances were processes automatically linked together and was production organized as a continuous flow. In general, however, although modern industry has been highly mechanized ever since the 1920s, the mechanized parts have not as a rule been linked together. Electric-light bulbs, bottles and the components of innumerable mass-produced
英文文献及中文翻译撰写格式
关于毕业设计说明书（论文）英文文献及中文翻译撰写格式 为提高我校毕业生毕业设计说明书（毕业论文）的撰写质量，做到毕业设计说明书（毕业论文）在内容和格式上的统一和规范，特规定如下: 一、装订顺序 论文（设计说明书）英文文献及中文翻译内容一般应由3个部分组成，严格按以下顺序装订。 1、封面 2、中文翻译 3、英文文献（原文） 二、书写格式要求 1、毕业设计（论文）英文文献及中文翻译分毕业设计说明书英文文献及中文翻译和毕业论文英文文献及中文翻译两种，所有出现相关字样之处请根据具体情况选择“毕业设计说明书” 或“毕业论文”字样。 2、毕业设计说明书（毕业论文）英文文献及中文翻译中的中文翻译用Word 软件编辑，英文文献用原文，一律打印在A4幅面白纸上，单面打印。 3、毕业设计说明书（毕业论文）英文文献及中文翻译的上边距:30mm；下边距:25mm；左边距:3Omm；右边距:2Omm；行间距1.5倍行距。 4、中文翻译页眉的文字为“中北大学2019届毕业设计说明书” 或“中北大学××××届毕业论文”，用小四号黑体字，页眉线的上边距为25mm；页脚的下边距为18mm。 5、中文翻译正文用小四号宋体，每章的大标题用小三号黑体，加粗，留出上下间距为：段前0.5行，段后0.5行；二级标题用小四号黑体，加粗；其余小标题用小四号黑体，不加粗。 6、文中的图、表、附注、公式一律采用阿拉伯数字分章编号。如图1.2，表2.3，附注3.2或式4.3。 7、图表应认真设计和绘制,不得徒手勾画。表格与插图中的文字一律用5号宋体。
每一插图和表格应有明确简短的图表名，图名置于图之下，表名置于表之上，图表号与图表名之间空一格。插图和表格应安排在正文中第一次提及该图表的文字的下方。当插图或表格不能安排在该页时，应安排在该页的下一页。 图表居中放置，表尽量采用三线表。每个表应尽量放在一页内，如有困难，要加“续表X.X”字样，并有标题栏。 图、表中若有附注时，附注各项的序号一律用阿拉伯数字加圆括号顺序排，如:注①。附注写在图、表的下方。 文中公式的编号用圆括号括起写在右边行末顶格，其间不加虚线。 8、文中所用的物理量和单位及符号一律采用国家标准，可参见国家标准《量和单位》(GB3100~3102-93)。 9、文中章节编号可参照《中华人民共和国国家标准文献著录总则》。
英语翻译学习资料(含中英文解释)
例1.Winners do not dedicate their lives to a concept of what they imagine they should be, rather, they are themselves and as such do not use their energy putting on a performance, maintaining pretence and manipulating（操纵） others . They are aware that there is a difference between being loved and acting loving, between being stupid and acting stupid, between being knowledgeable and acting knowledgeable. Winners do not need to hide behind a mask. 1.dedicate to 把时间，精力用于 2.pretence 虚伪，虚假 6 ．1 斤斤于字比句次，措辞生硬 例2.Solitude is an excellent laboratory in which to observe the extent to which manners and habits are conditioned by others. My table manners are atrocious( 丑恶)—in this respect I've slipped back hundreds of years in fact, I have no manners whatsoever（完全，全然）. If I feel like it, I eat with my fingers, or out of a can, or standing up —in other words, whichever is easiest. 孤独是很好的实验室，正好适合观察一个人的举止和习惯在多大程度上受人制约。如今我吃东西的举止十分粗野；这方面一放松就倒退了几百年，实在是一点礼貌也没有。我高兴就用手抓来吃，（eat out of a can）开个罐头端着吃，站着吃；反正怎么省事就怎么吃。 3.Whatsoever 完全，全然 1.Be conditioned by 受……制约 2.Atrocious 丑恶 6 ．2 结构松散，表达过于口语化 例3．有一次，在拥挤的车厢门口，我听见一位男乘客客客气气地问他前面的一位女乘客：“您下车吗？”女乘客没理他。“您下车吗？”他又问了一遍。女乘客还是没理他。他耐不住了，放大声问：“下车吗？”，那女乘客依然没反应。“你是聋子，还是哑巴？”他急了，捅了一下那女乘客，也引起了车厢里的人都往这里看。女乘客这时也急了，瞪起一双眼睛，回手给了男乘客一拳。（庄绎传，英汉翻译教程，1999 ：练习 3 ） 译文1：Once at the crowded door of the bus, I heard a man passenger asked politely a woman passenger before him: “Are you getting off?” The woman made no
中英文翻译与文献
Monolithic integrated circuit history The monolithic integrated circuit was born in the late-1970s, has experienced SCM, MCU, the SOC three big stages. SCM namely monolithic microcomputer (Single Chip Microcomputer) the stage, mainly seeks the best monolithic shape embedded system's best architecture. “the innovation pattern” obtains successfully, has established SCM and the general-purpose calculator completely different development path. In founds on the embedded system independent development path, Intel Corporation has lasting achievements. MCU namely micro controller (Micro Controller Unit) the stage, the main technological development direction is: Expands unceasingly when satisfies the embedded application, the object system request's each kind of peripheral circuit and the interface circuit, underline its object intellectualization control. It involves the domain is related with the object system, therefore, develops the MCU heavy responsibility to fall inevitably on electrical, the electronic technology factory. Looking from this angle, Intel fades out the MCU development also to have its objective factor gradually. Is developing the MCU aspect, the most famous factory family belongings count Philips Corporation. Philips Corporation by it in embedded application aspect huge superiority, MCS-51 from monolithic microcomputer rapidly expand to micro controller. Therefore, when we review the embedded system development path, do not forget Intel and the Philips historical merit. Monolithic integrated circuit is the embedded system's road of independent development, to the MCU stage development's important attribute, seeks application system's on chip maximized solution;
关于LED的外文文献和中文译文
多个LED发光装置的新型采集系统 作为光源的一种，发光二极管（LED）有很多优点。LED集成度更高，颜色种类多，使用寿命更长，而且工作电压较低。但是，它仍有一个非常大的缺陷：一只LED的光照强度还是比较低。这个缺点导致显示屏上的光通量不会很高。但是无论如何，LED还是以其出色的性能在低电压装置中普遍应用。因此，利用此系统采集多个LED的光，集成为更高强度的照明装置。本设计提出三种采集系统，来实现增强光强的功能。效率最好的一种采集系统可以达到96%。同时，还分析了本系统的制造误差以及预算。 1 简介 利用传统的光源来设计一个便携式探照灯，尺寸和能耗会很大。而利用LED 来设计将会避免这些问题。LED有很多优点：节能、体积较小、使用寿命长（约100,103小时）等，尤其是LED的光很适合环境工作。Carel Zeiss和Philips打算用LED光源设计两种便携式探照灯。尽管LED有诸多优点，可以让他们设计出的探照灯更加便携和小巧，但是由于光学元件的转换效率问题，导致系统有很多困难。解决这个困难将是本文研究的重点。通常，用一种合成非线性集中器（CPC）来减小分散度。但是，这种传统的CPC采集效率仅为72%，必须要改善采集效率来提高光的利用率。本文中将解决分散度和采集效率两个问题。为实现这个目标，设计了三种不同的采集系统，以提高效率，下面逐一介绍。 2 仿真部分 利用光学仿真软件和标签查找模块（BRO），来设计并分析采集系统的性能。LED光源部分来自Osram-Opical半导体。远程LED光源是一种Lambertian模式，LED的规格见表1。 在采集系统的底部有四个LED。系统各个LED之间的位置关系如图1。通光部分为2.1×2.1mm2，孔径3.26mm。LED阵列对称的分布于系统的底部。 采集系统的第一个光学元件为均质器。这个均质器的受光角度是12.5°。因此，这个系统就是要把LED的受光角度的范围控制在±60°到±12.5°之间。均质器的收集效率和能量分布能用来判断此采集系统。 3 新采集系统的说明 这里是三个新的采集系统：示踪的新设计I，新设计II，新设计III。在下一