英文翻译
英语原文：
. Introducing Classes
The only remaining feature we need to understand before solving our bookstore problem is how to write a data structure to represent our transaction data. In C++ we define our own data structure by defining a class. The class mechanism is one of the most important features in C++. In fact, a primary focus of the design of C++ is to make it possible to define class types that behave as naturally as the built-in types themselves. The library types that we've seen already, such as istream and ostream, are all defined as classesthat is,they are not strictly speaking part of the language.
Complete understanding of the class mechanism requires mastering a lot of information. Fortunately, it is possible to use a class that someone else has written without knowing how to define a class ourselves. In this section, we'll describe a simple class that we canuse in solving our bookstore problem. We'll implement this class in the subsequent chapters as we learn more about types,expressions, statements, and functionsall of which are used in defining classes.
To use a class we need to know three things:
What is its name?
Where is it defined?
What operations does it support?
For our bookstore problem, we'll assume that the class is named Sales_item and that it is defined in a header named Sales_item.h.
The Sales_item Class
The purpose of the Sales_item class is to store an ISBN and keep track of the number of copies sold, the revenue, and average sales price for that book. How these data are stored or computed is not our concern. To use a class, we need not know anything about how it is implemented. Instead, what we need to know is what operations the class provides.
As we've seen, when we use library facilities such as IO, we must include the associated headers. Similarly, for our own classes, we must make the definitions associated with the class available to the compiler. We do so in much the same way. Typically, we put the class definition into a file. Any program that wants to use our class must include that file.
Conventionally, class types are stored in a file with a name that, like the name of a program source file, has two parts: a file name and a file suffix. Usually the file name is the same as the class defined in the header. The suffix usually is .h, but some programmers use .H, .hpp, or .hxx. Compilers usually aren't picky about header file names, but IDEs sometimes are. We'll assume that our class is defined in a file named Sales_item.h.
Operations on Sales_item Objects
Every class defines a type. The type name is the same as the name of the class. Hence, our Sales_item class defines a type named
Sales_item. As with the built-in types, we can define a variable of a class type. When we write "Sales_item item" we are saying that item is an object of type Sales_item. We often contract the phrase "an object of type Sales_item" to"aSales_ item object" or even more simply to "a Sales_item."
In addition to being able to define variables of type Sales_item, we can perform the following operations on Sales_item objects:
Use the addition operator, +, to add two Sales_items,
Use the input operator, << to read a Sales_item object,
Use the output operator, >> to write a Sales_item object,
Use the assignment operator, =, to assign one Sales_item object to another,
Call the same_isbn function to determine if two Sales_items refer to the same book.
Classes are central to most C++ programs: Classes let us define our own types that are customizedfor the problems we need to solve, resulting in applications that are easier to write and understand.Well-designed class types can be as easy to use as the built-in types.
A class defines data and function members: The data members store the state associated with objectsof the class type, and the functions perform operations that give meaning to the data. Classeslet us separate implementation and interface. The interface specifies the operations that the classsupports. Only the implementor of the class need know or care about the details of the implementation. This separation reduces the bookkeeping aspects that make programming tedious anderror-prone.
Class types often are referred to as abstract data types. An abstract data type treats the data(state) and operations on that state as a single unit. We can think abstractly about what the classd oes, rather than always having to be aware of how the class operates. Abstract data types arefundamental to both object-oriented and generic programming.
Data abstraction is a programming (and design) technique that relies on the separation of interfaceand implementation. The class designer must worry about how a class is implemented, but programmersthat use the class need not know about these details. Instead, programmers who use a type need to know only the type's interface; they can think abstractly about what the type does rather than concretely about how the type works.
Encapsulation is a term that describes the technique of combining lower-level elements to forma new, higher-level entity. A function is one form of encapsulation: The detailed actions performedby the function are encapsulated in the larger entity that is the function itself. Encapsulated elements hide the details of their implementationwe may call a function but have no access to the statements that it executes. In the same way, a class is an encapsulated entity: It represents an aggregation of several members, and most (well-designed) class types hide the members that implement the type.
If we think about the library vector type, it is an example of both data abstraction and
encapsulation. It is abstract in that to use it, we think about its interfaceabout the operations that it can perform. It is encapsulated because we have no access to the details of how the type is representated nor to any of its implementation artifacts. An array, on the other hand, is similar in concept to a vector but is neither abstract nor encapsulated. We manipulate an array directly by accessing the memory in which the array is stored.
Not all types need to be abstract. The library pair class is a good example of a useful, well-designed class that is concrete rather than abstract. A concrete class is a class that exposes, rather than hides, its implementation.
Some classes, such as pair, really have no abstract interface. The pair type exists to bundle two data members into a single object. There is no need or advantage to hiding the data members. Hiding the members in a class like pair would only complicate the use of the type.
Even so, such types often have member functions. In particular, it is a good idea for any class that has data members of built-in or compound type to define constructor(s) to initialize those members. The user of the class could initialize or assign to the data members but it is less error-prone for the class to do so.
Programmers tend to think about the people who will run their applications as "users." Applicationsare designed for and evolve in response to feedback from those who ultimately "use" the applications. Classes are thought of in a similar way: A class designer designs and implements a class for "users" of that class. In this case, the "user" is a programmer, not the ultimate user of the application.
Authors of successful applications do a good job of understanding and implementing the needs ofthe application's users. Similarly, well-designed, useful classes are designed with a close attention to the needs of the users of the class.
In another way, the division between class designer and class user reflects the division betweenusers of an application and the designers and implementors of the application. Users care only if the application meets their needs in a cost-effective way. Similarly, users of a class care only about its interface. Good class designers define a class interface that is intuitive and easy to use. Users care about the implementation only in so far as the implementation affects their use of the class. If the implementation is too slow or puts burdens on users of the class, then the users must care. In well-designed classes, only the class designer worries about the implementation.
In simple applications, the user of a class and the designer of the class might be one and the same person. Even in such cases, it is useful to keep the roles distinct. When designing the interface to a class, the class designer should think about how easy it will be to use the class. When using the class, the designer shouldn't think about how the class works.
When referring to a "user," the context makes it clear which kind of user is meant. If we speak of "user code" or the "user" of the Sales_item class, we mean a programmer who
is using a class in writing an application. If we speak of the "user" of the bookstore application, we mean the manager of the store who is running the application.
Data abstraction and encapsulation provide two important advantages:
1.Class internals are protected from inadvertent user-level errors, which might corrupt the state of the object.
2.The class implementation may evolve over time in response to changing requirements or bug reports without requiring change in user-level code.
By defining data members only in the private section of the class, the class author is free to make changes in the data. If the implementation changes, only the class code needs to be examined to see what affect the change may have. If data are public, then any function that directly accesses the data members of the old representation might be broken. It would be necessary to locate and rewrite all those portions of code that relied on the old pesentation before the program could be used again.
Similarly, if the internal state of the class is private, then changes to the member data can happen in only a limited number of places. The data is protected from mistakes that users might introduce. If there is a bug that corrupts the object's state, the places to look for the bug are localized: When data are private, only a member function could be responsible for the error. The search for the mistake is limited, greatly easing the problems of maintenance and program correctness.
If the data are private and if the interface to the member functions does not change, then user functions that manipulate class objects require no change.
Because changing a class definition in a header file effectively changes the text of every source file that includes that header, code that uses a class must be recompiled when the class changes.
Classes are the most fundamental feature in C++. Classes let us define new types that are tailored to our own applications, making our programs shorter and easier to modify.
Data abstractionthe ability to define both data and function membersand encapsulationthe ability to protect class members from general accessare fundamental to classes. Member functions define the interface to the class. We encapsulate the class by making the data and functions used by the implementation of a class private.
Classes may define constructors, which are special member functions that control how objects of the class are initialized. Constructors may be verloaded. Every constructor should initialize every data member. Constructors should use a constructor initializer list to initialize the data members. Initializer lists are lists of namevalue pairs where the name is a member and the value is an initial value for that member.
Classes may grant access to their nonpublic members to other classes or functions. A class grants access by making the class or function a friend.
Classes may also define mutable or static members. A mutable member is a data member that is never const; its value may be changed inside a const member function. A
static member can be either function or data; static members exist independently of the objects of the class type.
Copy Control
Each type, whether a built-in or class type, defines the meaning of a (possibly empty) set of operations on objects of that type. We can add two int values, run size on a vector, and so on. These operations define what can be done with objects of the given type.
Each type also defines what happens when objects of the type are created. Initialization of objects of class type is defined by constructors. Types also control what happens when objects of the type are copied, assigned, or destroyed. Classes control these actions through special member functions: the copy constructor, the assignment operator, and the destructor. This chapter covers these operations.
When we define a new type, we specifyexplicitly or implicitlywhat happens when objects of that type are copied, assigned, and destroyed. We do so by defining special members: the copy constructor, the assignment operator, and the destructor. If we do not explicitly define the copy constructor or the assignment operator, the compiler will (usually) define them for us.
The copy constructor is a special constructor that has a single parameter that is a (usually const) reference to the class type. The copy constructor is used explicitly when we define a new object and initialize it from an object of the same type. It is used implicitly when we pass or return objects of that type to or from functions.
Collectively, the copy constructor, assignment operator, and destructor are referred to as copy control. The compiler automatically implements these operations, but the class may define its own versions.
Copy control is an essential part of defining any C++ class. Programmers new to C++ are often confused by having to define what happens when objects are
copied, assigned, or destroyed. This confusion is compounded because if we do not explicitly define these operations, the compiler defines them for usalthough they might not behave as we intend.
Often the compiler-synthesized copy-control functions are finethey do exactly the work that needs to be done. But for some classes, relying on the default definitions leads to disaster. Frequently,the most difficult part of implementing the copy-control operations is recognizing when we need to override the default versions. One especially common case that requires the class to define its own the copy-control members is if the class has a pointer member.
The Copy Constructor
The constructor that takes a single parameter that is a (usually const) reference to an object of the class type itself is called the copy constructor. Like the default constructor, the copy constructor can be implicitly invoked by the compiler. The copy constructor is used to:
1.Explicitly or implicitly initialize one object from another of the same type;
2.Copy an object to pass it as an argument to a function;
3.Copy an object to return it from a function;
4.Initialize the elements in a sequential container;
5.Initialize elements in an array from a list of element initializers.
Forms of Object Definition
Recall that C++ supports two forms of initialization (Section 2.3.3, p. 48): direct and copy.Copy-initialization uses the = symbol, and direct-initialization places the initializer in parentheses.
The copy and direct forms of initialization, when applied to objects of class type, are subtly different. Direct-initialization directly invokes the constructor matched by the arguments. Copy-initialization always involves the copy constructor. Copy-initialization first uses the indicated constructor to create a temporary object (Section 7.3.2, p. 247). It then uses the copy constructor to copy that temporary into the one we are creating: string null_book = "9-999-99999-9"; // copy-initialization
string dots(10, '.'); // direct-initialization
string empty_copy = string(); // copy-initialization
string empty_direct; // direct-initialization
For objects of class type, copy-initialization can be used only when specifying a single argument or when we explicitly build a temporary object to copy.
When dots is created, the string constructor that takes a count and a character is called and directly initializes the members in dots. To create null_book, the compiler first creates a temporary by invoking the string constructor that takes a C-style character string parameter. The compiler then uses the string copy constructor to initialize null_book as a copy of that temporary.
The initialization of empty_copy and empty_direct both call the string default constructor. In the first case, the default constructor creates a temporary object, which is then used by the copy constructor to initialize empty_copy. In the second case, the default constructor is run directly on empty_direct.
The copy form of initialization is primarily supported for compatibility with C usage. When it can do so, the compiler is permitted (but not obligated) to skip the copy constructor and create the object directly.
Usually the difference between direct- or copy-initialization is at most a matter of low-level optimization. However, for types that do not support copying, or when using a constructor that is nonexplicit (Section 12.4.4, p. 462) the distinction can be essential: ifstream file1("filename"); // ok: direct initialization
ifstream file2 = "filename"; // error: copy constructor is private
// This initialization is okay only if
// the Sales_item(const string&) constructor is not explicit
Sales_item item = string("9-999-99999-9");
The initialization of file1 is fine. The ifstream class defines a constructor that can be called with a C-style string. That constructor is used to initialize file1.
The seemingly equivalent initialization of file2 uses copy-initialization. That definition is not okay. We cannot copy objects of the IO types (Section 8.1, p. 287), so we cannot use copy-initialization on objects of these types.
Whether the initialization of item is okay depends on which version of our Sales_item class we are using. Some versions define the constructor that takes a string as explicit. If the constructor is explicit, then the initialization fails. If the constructor is not explicit, then the initialization is fine.
If a class does not define one or more of these operations, the compiler will define them automatically. The synthesized operations perform memberwise initialization, assignment, or destruction: Taking each member in turn, the synthesized operation does whatever is appropriate to the member's type to copy, assign, or destroy that member. If the member is a class type, the synthesized operation calls the corresponding operation for that class (e.g., the copy constructor calls the member's copy constructor, the destructor calls its destructor, etc.). If the member is a built-in type or a pointer, the member is copied or assigned directly; the destructor does nothing to destroy members of built-in or pointer type. If the member is an array, the elements in the array are copied, assigned, or destroyed in a manner appropriate to the element type.
中文译文
类的简介
解决书店问题之前，还需要弄明白如何编写数据结构来表示交易数据。C++ 中我们通过定义类来定义自己的数据结构。类机制是 C++ 中最重要的特征之一。事实上，C++ 设计的主要焦点就是使所定义的类类型的行为可以像内置类型一样自然。我们前面已看到的像 istream 和 ostream 这样的库类型，都是定义为类的，也就是说，它们严格说来不是语言的一部分。
完全理解类机制需要掌握很多内容。所幸我们可以使用他人写的类而无需掌握如何定义自己的类。在这一节，我们将描述一个用于解决书店问题的简单类。当我们学习了更多关于类型、表达式、语句和函数的知识（所有这些在类定义中都将用到）后，将会在后面的章节实现这个类。
使用类时我们需要回答三个问题：
类的名字是什么？
它在哪里定义？
它支持什么操作？
对于书店问题，我们假定类命名为Sales_item 且类定义在命名为Sales_item.h 的头文件中。
Sales_item 类
Sales_item 类的目的是存储 ISBN 并保存该书的销售册数、销售收入和平均售价。我们不关心如何存储或计算这些数据。使用类时我们不需要知道这个类是怎样实现的，相反，我们需要知道的是该类提供什么操作。
正如我们所看到的，使用像 IO 一样的库工具，必须包含相关的头文件。类似地，对于自定义的类，必须使得编译器可以访问和类相关的定义。这几乎可以采用同样的方式。一般来说，我们将类定义放入一个文件中，要使用该类的任何程序都必须包含这个文件。
依据惯例，类类型存储在一个文件中，其文件名如同程序的源文件名一样，由文件名和文件后缀两部分组成。通常文件名和定义在头文件中的类名是一样的。通常后缀是 .h，但也有一些程序员用 .H、.hpp 或 .hxx。编译器通常并不挑剔头文件名，但 IDE 有时会。假设我们的类定义在名为 Sale_item.h 的文件中。
Sales_item 对象上的操作
每个类定义一种类型，类型名与类名相同。因此，我们的 Sales_item 类定义了一种命名为 Sales_item 的类型。像使用内置类型一样，可以定义类类型的变量。当写下" Sales_item item",就表示 item 是类型 Sales_item 的一个对象。通常将“类型 Sales_item 的一个对象”简称为“一个 Sales_item 对象”，或者更简单地简称为“一个 Sales_item”。
除了可以定义 Sales_item 类型的变量，我们还可以执行 Sales_item 对象的以下操作：
使用加法操作符，+，将两个 Sales_item 相加;
文献出处：Bedard J C, Hoitash R, et al. The development of the enterprise risk management theory [J]. Contemporary Accounting Research, 2014, 30(4): 64-95. （声明：本译文归百度文库所有，完整译文请到百度文库。） 原文 The development of the enterprise risk management theory Bedard J C, Hoitash R Abstract Enterprise risk management as an important field of risk management disciplines, in more than 50 years of development process of the implementation of dispersing from multiple areas of research to the integration of comprehensive risk management framework evolution, the theory of risk management and internal audit and control theory are two major theoretical sources of risk management theory has experienced from the traditional risk management, financial volatility to the development of the enterprise risk management, risk management and internal audit and control theory went through the internal accounting control and internal control integrated framework to the evolution of enterprise risk management, the development of the theory of the above two points to the direction of the enterprise risk management, finally realizes the integration development, enterprise risk management theory to become an important part of enterprise management is indispensable. Keywords: enterprise risk management, internal audit the internal control 1 The first theory source, evolution of the theory of risk management "Risk management" as a kind of operation and management idea, has a long history: thousands of years ago in the west have "don't put all eggs in one basket" the proverb, the ancient Chinese famous "product valley hunger" allusions and "yicang ("
Statistical hypothesis testing Adriana Albu，Loredana Ungureanu Politehnica University Timisoara,adrianaa@aut.utt.ro Politehnica University Timisoara,loredanau@aut.utt.ro Abstract In this article,we present a Bayesian statistical hypothesis testing inspection, testing theory and the process Mentioned hypothesis testing in the real world and the importance of, and successful test of the Notes. Key words Bayesian hypothesis testing; Bayesian inference;Test of significance Introduction A statistical hypothesis test is a method of making decisions using data, whether from a controlled experiment or an observational study (not controlled). In statistics, a result is called statistically significant if it is unlikely to have occurred by chance alone, according to a pre-determined threshold probability, the significance level. The phrase "test of significance" was coined by Ronald Fisher: "Critical tests of this kind may be called tests of significance, and when such tests are available we may discover whether a second sample is or is not significantly different from the first."[1] Hypothesis testing is sometimes called confirmatory data analysis, in contrast to exploratory data analysis. In frequency probability,these decisions are almost always made using null-hypothesis tests. These are tests that answer the question Assuming that the null hypothesis is true, what is the probability of observing a value for the test statistic that is at [] least as extreme as the value that was actually observed?) 2 More formally, they represent answers to the question, posed before undertaking an experiment,of what outcomes of the experiment would lead to rejection of the null hypothesis for a pre-specified probability of an incorrect rejection. One use of hypothesis testing is deciding whether experimental results contain enough information to cast doubt on conventional wisdom. Statistical hypothesis testing is a key technique of frequentist statistical inference. The Bayesian approach to hypothesis testing is to base rejection of the hypothesis on the posterior probability.[3][4]Other approaches to reaching a decision based on data are available via decision theory and optimal decisions. The critical region of a hypothesis test is the set of all outcomes which cause the null hypothesis to be rejected in favor of the alternative hypothesis. The critical region is usually denoted by the letter C. One-sample tests are appropriate when a sample is being compared to the population from a hypothesis. The population characteristics are known from theory or are calculated from the population.
Inventory management Inventory Control On the so-called "inventory control", many people will interpret it as a "storage management", which is actually a big distortion. The traditional narrow view, mainly for warehouse inventory control of materials for inventory, data processing, storage, distribution, etc., through the implementation of anti-corrosion, temperature and humidity control means, to make the custody of the physical inventory to maintain optimum purposes. This is just a form of inventory control, or can be defined as the physical inventory control. How, then, from a broad perspective to understand inventory control? Inventory control should be related to the company's financial and operational objectives, in particular operating cash flow by optimizing the entire demand and supply chain management processes (DSCM), a reasonable set of ERP control strategy, and supported by appropriate information processing tools, tools to achieved in ensuring the timely delivery of the premise, as far as possible to reduce inventory levels, reducing inventory and obsolescence, the risk of devaluation. In this sense, the physical inventory control to achieve financial goals is just a means to control the entire inventory or just a necessary part; from the perspective of organizational functions, physical inventory control, warehouse management is mainly the responsibility of The broad inventory control is the demand and supply chain management, and the whole company's responsibility. Why until now many people's understanding of inventory control, limited physical inventory control? The following two reasons can not be ignored: First, our enterprises do not attach importance to inventory control. Especially those who benefit relatively good business, as long as there is money on the few people to consider the problem of inventory turnover. Inventory control is simply interpreted as warehouse management, unless the time to spend money, it may have been to see the inventory problem, and see the results are often very simple procurement to buy more, or did not do warehouse departments . Second, ERP misleading. Invoicing software is simple audacity to call it ERP, companies on their so-called ERP can reduce the number of inventory, inventory control, seems to rely on their small software can get. Even as SAP, BAAN ERP world, the field of
吉林化工学院理学院 毕业论文外文翻译English Title（Times New Roman ，三号） 学生学号：08810219 学生姓名：袁庚文 专业班级：信息与计算科学0802 指导教师：赵瑛 职称副教授 起止日期：2012.2.27～2012.3.14 吉林化工学院 Jilin Institute of Chemical Technology
1 外文翻译的基本内容 应选择与本课题密切相关的外文文献（学术期刊网上的），译成中文，与原文装订在一起并独立成册。在毕业答辩前，同论文一起上交。译文字数不应少于3000个汉字。 2 书写规范 2.1 外文翻译的正文格式 正文版心设置为：上边距：3.5厘米，下边距：2.5厘米，左边距：3.5厘米，右边距：2厘米，页眉：2.5厘米，页脚：2厘米。 中文部分正文选用模板中的样式所定义的“正文”，每段落首行缩进2字；或者手动设置成每段落首行缩进2字，字体：宋体，字号：小四，行距：多倍行距1.3，间距：前段、后段均为0行。 这部分工作模板中已经自动设置为缺省值。 2.2标题格式 特别注意：各级标题的具体形式可参照外文原文确定。 1．第一级标题（如：第1章绪论）选用模板中的样式所定义的“标题1”，居左；或者手动设置成字体：黑体，居左，字号：三号，1.5倍行距，段后11磅，段前为11磅。 2．第二级标题（如：1.2 摘要与关键词）选用模板中的样式所定义的“标题2”，居左；或者手动设置成字体：黑体，居左，字号：四号，1.5倍行距，段后为0，段前0.5行。 3．第三级标题（如：1.2.1 摘要）选用模板中的样式所定义的“标题3”，居左；或者手动设置成字体：黑体，居左，字号：小四，1.5倍行距，段后为0，段前0.5行。 标题和后面文字之间空一格（半角）。 3 图表及公式等的格式说明 图表、公式、参考文献等的格式详见《吉林化工学院本科学生毕业设计说明书（论文）撰写规范及标准模版》中相关的说明。
Advantages of Managed Code Microsoft intermediate language shares with Java byte code the idea that it is a low-level language witha simple syntax , which can be very quickly translated intonative machine code. Having this well-defined universal syntax for code has significant advantages. Platform independence First, it means that the same file containing byte code instructions can be placed on any platform; atruntime the final stage of compilation can then be easily accomplished so that the code will run on thatparticular platform. In other words, by compiling to IL we obtain platform independence for .NET, inmuch the same way as compiling to Java byte code gives Java platform independence. Performance improvement IL is actually a bit more ambitious than Java bytecode. IL is always Just-In-Time compiled (known as JIT), whereas Java byte code was ofteninterpreted. One of the disadvantages of Java was that, on execution, the process of translating from Javabyte code to native executable resulted in a loss of performance. Instead of compiling the entire application in one go (which could lead to a slow start-up time), the JITcompiler simply compiles each portion of code as it is called (just-in-time). When code has been compiled.once, the resultant native executable is stored until the application exits, so that it does not need to berecompiled the next time that portion of code is run. Microsoft argues that this process is more efficientthan compiling the entire application code at the start, because of the likelihood that large portions of anyapplication code will not actually be executed in any given run. Using the JIT compiler, such code willnever be compiled.
五分钟搞定5000字－外文文献翻译 工具大全 建议收藏 在科研过程中阅读翻译外文文献是一个非常重要的环节，许多领域高水平的文献都是外文文献，借鉴一些外文文献翻译的经验是非常必要的。由于特殊原因我翻译外文文献的机会比较多，慢慢地就发现了外文文献翻译过程中的三大利器：G oogle“翻译”频道、金山词霸（完整版本）和CNKI“翻译助手"。 具体操作过程如下： 1.先打开金山词霸自动取词功能，然后阅读文献； 2.遇到无法理解的长句时，可以交给Google处理，处理后的结果猛一看，不堪入目，可是经过大脑的再处理后句子的意思基本就明了了； 3.如果通过Google仍然无法理解，感觉就是不同，那肯定是对其中某个“常用单词”理解有误，因为某些单词看似很简单，但是在文献中有特殊的意思，这时就可以通过CNKI的“翻译助手”来查询相关单词的意思，由于CNKI的单词意思都是来源与大量的文献，所以它的吻合率很高。 另外，在翻译过程中最好以“段落”或者“长句”作为翻译的基本单位，这样才不会造成“只见树木，不见森林”的误导。 注： 1、Google翻译： google，众所周知，谷歌里面的英文文献和资料还算是比较详实的。我利用它是这样的。一方面可以用它查询英文论文，当然这方面的帖子很多，大家可以搜索，在此不赘述。回到我自己说的翻译上来。下面给大家举个例子来说明如何用
吧 比如说“电磁感应透明效应”这个词汇你不知道他怎么翻译， 首先你可以在CNKI里查中文的，根据它们的关键词中英文对照来做，一般比较准确。 在此主要是说在google里怎么知道这个翻译意思。大家应该都有词典吧，按中国人的办法，把一个一个词分着查出来，敲到google里，你的这种翻译一般不太准，当然你需要验证是否准确了，这下看着吧，把你的那支离破碎的翻译在g oogle里搜索，你能看到许多相关的文献或资料，大家都不是笨蛋，看看，也就能找到最精确的翻译了，纯西式的！我就是这么用的。 2、CNKI翻译： CNKI翻译助手，这个网站不需要介绍太多，可能有些人也知道的。主要说说它的有点，你进去看看就能发现：搜索的肯定是专业词汇，而且它翻译结果下面有文章与之对应（因为它是CNKI检索提供的，它的翻译是从文献里抽出来的），很实用的一个网站。估计别的写文章的人不是傻子吧，它们的东西我们可以直接拿来用，当然省事了。网址告诉大家，有兴趣的进去看看，你们就会发现其乐无穷！还是很值得用的。 3、网路版金山词霸（不到1M）： 翻译时的速度： 这里我谈的是电子版和打印版的翻译速度，按个人翻译速度看，打印版的快些，因为看电子版本一是费眼睛，二是如果我们用电脑，可能还经常时不时玩点游戏，或者整点别的，导致最终SPPEED变慢，再之电脑上一些词典（金山词霸等）在专业翻译方面也不是特别好，所以翻译效果不佳。在此本人建议大家购买清华
软件专业毕业论文外文文献中英文翻译 Object landscapes and lifetimes Tech nically, OOP is just about abstract data typing, in herita nee, and polymorphism, but other issues can be at least as importa nt. The rema in der of this sect ion will cover these issues. One of the most importa nt factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object con trolled? There are differe nt philosophies at work here. C++ takes the approach that con trol of efficie ncy is the most importa nt issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocatio n and release, and con trol of these can be very valuable in some situati ons. However, you sacrifice flexibility because you must know the exact qua ntity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided desig n, warehouse man ageme nt, or air-traffic con trol, this is too restrictive. The sec ond approach is to create objects dyn amically in a pool of memory called the heap. In this approach, you don't know un til run-time how many objects you n eed, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is runnin g. If you n eed a new object, you simply make it on the heap at the point that you n eed it. Because the storage is man aged dyn amically, at run-time, the amount of time required to allocate storage on the heap is sig ni fica ntly Ion ger tha n the time to create storage on the stack. (Creat ing storage on the stack is ofte n a si ngle assembly in structio n to move the stack poin ter dow n, and ano ther to move it back up.) The dyn amic approach makes the gen erally logical assumpti on that objects tend to be complicated, so the extra overhead of finding storage and releas ing that storage will not have an importa nt impact on the creati on of an object .In additi on, the greater flexibility is esse ntial to solve the gen eral program ming problem. Java uses the sec ond approach, exclusive". Every time you want to create an object, you use the new keyword to build a dyn amic in sta nee of that object. There's ano ther issue, however, and that's the lifetime of an object. With Ian guages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no kno wledge of its lifetime. In a Ianguage like C++, you must determine programmatically when to destroy the
英文翻译 英语原文： . Introducing Classes The only remaining feature we need to understand before solving our bookstore problem is how to write a data structure to represent our transaction data. In C++ we define our own data structure by defining a class. The class mechanism is one of the most important features in C++. In fact, a primary focus of the design of C++ is to make it possible to define class types that behave as naturally as the built-in types themselves. The library types that we've seen already, such as istream and ostream, are all defined as classesthat is,they are not strictly speaking part of the language. Complete understanding of the class mechanism requires mastering a lot of information. Fortunately, it is possible to use a class that someone else has written without knowing how to define a class ourselves. In this section, we'll describe a simple class that we canuse in solving our bookstore problem. We'll implement this class in the subsequent chapters as we learn more about types,expressions, statements, and functionsall of which are used in defining classes. To use a class we need to know three things: What is its name? Where is it defined? What operations does it support? For our bookstore problem, we'll assume that the class is named Sales_item and that it is defined in a header named Sales_item.h. The Sales_item Class The purpose of the Sales_item class is to store an ISBN and keep track of the number of copies sold, the revenue, and average sales price for that book. How these data are stored or computed is not our concern. To use a class, we need not know anything about how it is implemented. Instead, what we need to know is what operations the class provides. As we've seen, when we use library facilities such as IO, we must include the associated headers. Similarly, for our own classes, we must make the definitions associated with the class available to the compiler. We do so in much the same way. Typically, we put the class definition into a file. Any program that wants to use our class must include that file. Conventionally, class types are stored in a file with a name that, like the name of a program source file, has two parts: a file name and a file suffix. Usually the file name is the same as the class defined in the header. The suffix usually is .h, but some programmers use .H, .hpp, or .hxx. Compilers usually aren't picky about header file names, but IDEs sometimes are. We'll assume that our class is defined in a file named Sales_item.h. Operations on Sales_item Objects
毕业论文（设计）外文翻译 题目：中国上市公司偏好股权融资：非制度性因素 系部名称：经济管理系专业班级:会计082班 学生姓名：任民学号： 200880444228 指导教师：冯银波教师职称:讲师 年月日
译文： 中国上市公司偏好股权融资：非制度性因素 国际商业管理杂志 2009.10 摘要：本文把重点集中于中国上市公司的融资活动，运用西方融资理论，从非制度性因素方面，如融资成本、企业资产类型和质量、盈利能力、行业因素、股权结构因素、财务管理水平和社会文化，分析了中国上市公司倾向于股权融资的原因，并得出结论，股权融资偏好是上市公司根据中国融资环境的一种合理的选择。最后，针对公司的股权融资偏好提出了一些简明的建议。 关键词：股权融资，非制度性因素，融资成本 一、前言 中国上市公司偏好于股权融资，根据中国证券报的数据显示，1997年上市公司在资本市场的融资金额为95.87亿美元，其中股票融资的比例是72.5％，，在1998年和1999年比例分别为72.6％和72.3％，另一方面，债券融资的比例分别是17.8％，24.9％和25.1％。在这三年，股票融资的比例，在比中国发达的资本市场中却在下跌。以美国为例，当美国企业需要的资金在资本市场上，于股权融资相比他们宁愿选择债券融资。统计数据显示，从1970年到1985年，美日企业债券融资占了境外融资的91.7％，比股权融资高很多。阎达五等发现，大约中国3/4的上市公司偏好于股权融资。许多研究的学者认为，上市公司按以下顺序进行外部融资：第一个是股票基金，第二个是可转换债券，三是短期债务，最后一个是长期负债。许多研究人员通常分析我国上市公司偏好股权是由于我们国家的经济改革所带来的制度性因素。他们认为，上市公司的融资活动违背了西方古典融资理论只是因为那些制度性原因。例如，优序融资理论认为，当企业需要资金时，他们首先应该转向内部资金（折旧和留存收益），然后再进行债权融资，最后的选择是股票融资。在这篇文章中，笔者认为，这是因为具体的金融环境激活了企业的这种偏好，并结合了非制度性因素和西方金融理论，尝试解释股权融资偏好的原因。
本科毕业设计（论文）中英文对照翻译 院（系部）电气工程与自动化 专业名称电子信息工程 年级班级 04级7班 学生姓名 指导老师
Infrared Remote Control System Abstract Red outside data correspondence the technique be currently within the scope of world drive extensive usage of a kind of wireless conjunction technique,drive numerous hardware and software platform support. Red outside the transceiver product have cost low, small scaled turn, the baud rate be quick, point to point SSL, be free from electromagnetism thousand Raos etc.characteristics, can realization information at dissimilarity of the product fast, convenience, safely exchange and transmission, at short distance wireless deliver aspect to own very obvious of advantage.Along with red outside the data deliver a technique more and more mature, the cost descend, red outside the transceiver necessarily will get at the short distance communication realm more extensive of application. The purpose that design this system is transmit cu stomer’s operation information with infrared rays for transmit media, then demodulate original signal with receive circuit. It use coding chip to modulate signal and use decoding chip to demodulate signal. The coding chip is PT2262 and decoding chip is PT2272. Both chips are made in Taiwan. Main work principle is that we provide to input the information for the PT2262 with coding keyboard. The input information was coded by PT2262 and loading to high frequent load wave whose frequent is 38 kHz, then modulate infrared transmit dioxide and radiate space outside when it attian enough power. The receive circuit receive the signal and demodulate original information. The original signal was decoded by PT2272, so as to drive some circuit to accomplish