Assignment Operator Could Not Be Generate Synonyms

my C++ page.

C-style cast - dangerous form of explicit type conversion; prefer new-style cast if you must use explicit type conversion. TC++PL 6.2.7, D&E 14.3.5.1.

C-style string - zero-terminated array of characters, supported by C standard libraryfunctions. A low-level and error-prone mechanism; where possible prefer strings. TC++PL 3.5.1, 20.3.7, 20.4.

C/C++ - (1) an abbreviation used when discussing similarities, differences, and compatibility issues of C and C++. (2) a mythical language referred to by people who cannot or do not want to recognize the magnitude of differences between the facilities offered by C and C++ or the significant differences in the programming styles supported by the two language. See also: multi-paradigm programming, object-oriented programming, generic programming, exception, template, user-defined type, C++ standard library.

C/C++ compatibility - C++ was designed to be as compatible as possible to C, but no more. This basically means as compatible as can be without compromising C++'s level of type safety. You can download Appendix B of TC++PL,. Compatibility, which describes incompatibilities and differences in facilities offered by C and C++. TC++PL B. D&E 2.7, 3.12, 4.5.

C89 - The 1989 ANSI standard for C based on K&R C with a few additions borrowed from C++, such as function prototypes and const. See also: K&R C, C99.

C99 - The 1999 ISO standard for C based on C89 with additions to support Fortran-style numeric computation. It also borrows a few more features, such as line comments (// comments) and declarations as statements, from C++.

call-by-reference - declaring a function argumenttype to be a reference, thus passing a reference rather than a value to the called function. See Also: call-by-value. TC++PL 5.5, D&E 3.7.

call-by-value - passing a copy of an argument to the called function. The semantics of function call is to pass a copy of an argument. The copy operation is defined by the argument type's copy constructor. See Also: call-by-reference. TC++PL 7.2.

cast - operator for explicit type conversion; most often best avoided. See also dynamic_cast, C-style cast, new-style cast. TC++PL 6.2.7, D&E 7.2, 14.2.2.1.

catch - keyword used to introduce a catch-clause.

catch(...) - catch every exception. TC++PL 14.3.2, D&E 16.5.

catch-clause - a part of a try-block that handles exceptions of a specified type. Also called a handler or an exception handler. TC++PL 8.3.1, 14.3, D&E 16.3-4.

cerr - standard unbuffered ostream for error or diagnostic output. TC++PL 21.2.1.

Cfront - the front-end of Bjarne Stroustrup's original C++compiler. D&E 3.3.

char - character type; typically an 8-bitbyte. See also: wchar_t. TC++PL 4.3, C.3.4.

char* - pointer to a char or an array of char. Typically assumed to point to a C-style string. Prefer a standard library string over a C-style string when you can. TC++PL 2.3.3, 13.5.2.

character set - a set of integer values with a mapping to character representations; for example, ASCII (ANSI13.4-1968) gives meaning to the values 0-127. ASCII is C++'s representation character set, the character set used to represent program source text. TC++PL C.3. D&E 6.5.3.

character type - char, unsigned char, and signed char. These are three distinct types. See also: wchar_t. TC++PL 2.3.1, 4.3, C.3.4.

cin - standard istream. TC++PL 3.6, 21.3.1 D&E 8.3.1.

class - a user-defined type. A class can have member functions, member data, member constants, and member types. A class is thee primary mechanism for representing concepts in C++. See also: template class. TC++PL 2.5.2, 10, D&E 2.3.

class hierarchy - a collection of classes organized into a directed acyclic graph (DAG) by derived/base relationships. TC++PL 2.6.2, 12, 15, D&E 1.1, 7.2, 8.2.3.

class template - see template class.

Classic C - see K&R C.

clone - a function that makes a copy of an object; usually a clone function relies on run-time information (e.g. a virtual function call) to correctly copy an object given only a pointer or reference to a sub-object.

closure - object representing a context. C++ does not have general closures, but function objects can be efficiently used to hold specific parts of a context relevant to a computation. TC++PL 22.4.7, 18.4.

co-variant return type - see return type relaxation.

code generator - the part of a compiler that takes the output from the front-end and generates code from it. See also: back-end, optimizer.

collection - a term sometimes used as a synonym for container.

Comeau C++ - a family of ports of the EDG C++ front-end.

comment - block comment /* ... */ or line comment // ...

compatibility - see C/C++ compatibility.

compiler - the part of a C++ implementation that produces object code from a translation unit. See also: front-end, back-end.

complex - standard library complex number template parameterized by scalar type. TC++PL 11.3, 22.5, D&E 3.6.1, 8.5, 15.10.2.1.

compound statement - sequence of statements enclosed in curly braces: { ... } See also: try-block. TC++PL 2.3, 6.3.

concept - a C++ language construct, providing type chaecking for template arguments.

concept checking - see constraint.

concrete type - a type without virtualfunctions, so that objects of the type can be allocated on the stack and manipulated directly (without a need to use pointers or references to allow the possibility for derived classes). Often, small self-contained classes. See also abstract class, vector, list, string, complex. TC++PL 25.2.

const - attribute of a declaration that makes the entity to which it refers readonly. See also: const member function. TC++PL 5.4, D&E 3.8.

const definition - declaration of a const including an initializer.

const member function - member function declared not to modify the state of the object for which it is called. Can be called for const objects only. TC++PL 10.2.6, D&E 13.3.

constant - literal, object or value declared const, or enumerator.

constant expression - expression of integral type that is evaluated at compile time. TC++PL C.5.

constraint - rule that restricts the set of acceptable arguments for a templateparameter. For example "the argument must have + and - operators". Examples. D&E 15.4.

constructor - member function with the same name as its class, used to initialize objects of its class. Often used to establish an invariant for the class. Often used to acquire resources. A constructor establishes a local environment in which member functions execute. See also: order of construction, destructor. TC++PL 10.2.3, D&E 2.11.1.

const_cast - a type conversion operation that conversion between types that differ in const and volatile type modifiers only. See also: cast. TC++PL 15.4.2.1, D&E 14.3.4.

container - (1) object that holds other objects. (2) type of object that holds other objects. (3) template that generates types of objects that hold other objects. (4) standard library template such as vector, list, and map. TC++PL 16.2, 16.2.3, 17, D&E 15.3.

controlled variable - a variable used to express the part of the exit condition of a loop that varies each time around the loop. For example ``i'' in for (int i=0; i<max; ++i) f(i);

conversion - explicit type conversion or implicit type conversion. See also: user-defined type conversion.

conversion operator - operator function specifying a conversion from a user-defined type to either another user-defined type or a built-in type. Note that constructors cannot define conversions to built-in types. TC++PL 11.4, D&E 3.6.3.

copy assignment - an assignment accepting an object of the class itself as its argument, typically Z::operator=(const Z&). A copy assignment is used for assignment of an object of type T with an object of type T. If a copy assignment is not declared for a class, memberwise copy is used. See also: copy constructor. TC++PL 10.4.4.1, 10.4.6.3 D&E 11.4.

copy constructor - a constructor accepting an object of the class itself as its argument, typically Z::Z(const Z&). A copy constructor is used for initialization of objects of type T with objects of type T. If a copy constructor is not declared for a class, memberwise initialization is used. See also: call-by-value, argument passing, value return, copy assignment. TC++PL 10.4.4.1, 10.4.6.3, D&E 11.4.

copy() - standard algorithm for copying one sequence into another. The two sequences need not be of the same type. TC++PL 18.6.1.

copying class object - an object of a class is copied by the class' copy assignment and copy constructors. The default meaning of these operations is memberwise copy. TC++PL 10.4.4.1, 10.4.6.3 D&E 11.4.

cout - standard ostream. TC++PL 3.4, 21.2.1, D&E 8.3.1.

cpp - see preprocessor.

crosscast - a cast from a class to a sibling class. See also: dynamic_cast, upcast, downcast. TC++PL 15.4.

Currying - producing a function of N-M arguments by specifying M arguments for a function of N arguments. See also: binder, default argument. TC++PL 18.4.4.1.

D&E - Bjarne Stroustrup: The Design and Evolution of C++. Addison Wesley. 1994. A book describing why C++ looks the way it does - the closest to a design rationale that we have for C++.

data abstraction - programming relying on user-defined types with well-defined interfaces. See also: generic programming and object-oriented programming. TC++PL 2.5, 24.2.2, D&E 9.2.1.

data hiding - see information hiding

data member - member of a class that can hold a value. A memer can be a static member or a non-static member. TC++PL 2.5.2-3, 10.2, D&E 2.3, 2.5.2.

declaration - an introduction of a name into a scope. The type of the name must be specified. If the declaration also specifies the entity to which the name refers, the declaration is also a definition. TC++PL 4.9, D&E 3.11.5.

decltype - C++ox operator meaning the type of its operand. For example: constdouble& d1 =2.0; decltype(d1) d2; (d2 will also be a const double&). Primarily useful for writing forwarding functions in generic programming.

default argument - a value specified for an argument in a function declaration, to be used if a call of the function doesn't specify a value for that argument. This is commonly used to allow a simple interface for common uses while making it easy to use less common facilities by specifying more arguments. See also: default template argument, binder. TC++PL 7.5, 10.2.3, D&E 2.12.2.

default constructor - constructor requiring no arguments. Used for default initialization. TC++PL 10.4.2, 10.4.6, D&E 2.12.2, 15.11.3.

default template argument - a type or value specified for an argument in a templatedeclaration, to be used if a use of the template doesn't provide a type or value for that argument. This is commonly used to allow a simple interface for common uses while making it easy to use less common facilities by specifying more arguments. See also: default argument. TC++PL 13.4.1, B.3.5.

default value - value defined by a default constructor. For built-in types, the default value is defined to be 0. TC++PL 4.9.5, 10.3.1, 10.4.2 D&E 15.11.3.

definition - a declaration that specifies the entity to which the declared name refers. See also: one definition rule, variable definition, const definition, template definition, function definition. TC++PL 4.9, D&E 15.11.3.

delayed evaluation - technique for eliminating temporary values, and in general to delay a computation until sufficient information is available to do it well. TC++PL 21.4.6.3, 22.4.7.

delete - object destruction operator. Invokes destructor, if any. See also: resource management, memory management, garbage collection, operator delete(). TC++PL 6.2.6, D&E 2.3, 10.2.

deprecated feature - feature left in a programming language for historical reasons only. The standard s committee recommends against its use and warns that it may be removed in future revisions of the standard.

deque - double-ended queue (pronounced "deck"). A standard librarytemplate alowing insertions and deletions at both ends. Use a vector if you need insertions and deletions only at one end (as is typical). Use a list if you need frequent insertions and deletions in the middle. TC++PL 17.2.3.

derived class - a class with one or more base classes TC++PL 2.6.2, 12, 15, D&E 3.5.

design - creating a clean and reasonably simple structure of a system TC++PL 23.3.

design of C++ - see D&E.

destructor - member of a class used to clean up before deleting an object. It's name is its class' name prefixed by '~'. For example, Foo's destructor is ~Foo(). Often used to release resources. A destructor is implicitly called whenever an object goes out of scope or is deleted. See also: virtual destructor, order of destruction. TC++PL 10.4.2, D&E 2.11.1, 3.11.2.

digraph - alternative representation for C++ representation characters that doesn't exist in every national character set, such as {, }, [, ], and #: <%, %., <:, :>, and %:. TC++PL C.3.1.

double - double-precision floating-point number. TC++PL 4.5.

double dispatch - a technique for selecting a function to be invoked on the dynamic type of two operands. TC++PL 21.2.3.1, D&E 13.8.

downcast - a cast from a base class to one of its derived classes. The name reflects the fact that in programming, trees tend to be drawn growing downwards from the roots. See also: dynamic_cast, upcast, crosscast. TC++PL 15.4.

dynamic memory - see free store.

dynamic type - the type of an object as determined at run-time; e.g. using dynamic_cast or typeid. Also known as most-derived type.

dynamic type safety - type safety enforced at run time (typically requiring a programmer to catchexceptions to deal with violations). An example is range checking for vectors.

dynamic_cast - a type conversion operation that performs safe conversions using on run time type information. Used for navigation of a class hierarchy. See also: downcast, crosscast, static_cast. TC++PL 15.4.1, D&E 14.2.2, 14.3.2.1.

EDG C++ front-end - a quality C++compilerfront-end, which is the core of several well-regarded C++ compilers.

element - an object in a container.

encapsulation - the enforcement of abstraction by mechanisms that prevent access to implementation details of an object or a group of objects except through a well-defined interface. C++ enforces encapsulation of private and proteced members of a class as long as users do not violate the type system using casts. See also: interface and access control. TC++PL 15.3, 24.3.7.4, D&E 2.10.

enum - keyword for declaring enumerations. TC++PL 4.8, D&E 11.7.

enumeration - a user-defined type consisting of a set of named values. TC++PL 4.8, D&E 11.7.

enumerator - a name identifying a value of an enumeration. TC++PL 4.8, D&E 11.7.

equality operator - see ==.

error handling - see exception handling.

escape character - the character \, also called backslash, sed an initial character in representations of characters that cannot be represented by a single ASCII character, such as newline ('\n') and horizontal tab ('\t'). TC++PL C.3.2.

exception - object thrown by a throw-statement and (potentially) caught by an exception handler associated by a try-block. See also: exception safety, termination semantics, catch. TC++PL 8.3, 14.2, D&E 16.

exception handler - a catch-clause associated with a try-block for handling exceptions of a specified type. TC++PL 8.3.1, 14.3, D&E 16.3-4.

exception handling - the primary way of reporting an error that cannot be handled locally. An exception is thrown and will be caught by an exception handler or terminate() will be called. See also: exception safety, termination semantics, try-block, throw, catch. TC++PL 8.3, 14, E, D&E 16.

exception safety - the notion that a program is structured so that throwing an exception doesn't cause unintended side effects. See also: basic guarantee, strong guarantee, and nothrow guarantee. You can download Appendix E Standard-Library Exception Safety of TC++PL describing techniques for exception handling. TC++PL E.2.

executable file - the result of linking the object files of a complete program. See also: compiler, linker.

explicit - keyword used to define a constructor so that it isn't used for implicit conversions. TC++PL 11.7.1.

explicit call of constructor - See placement new.

explicit call of destructor - destructors are implicitly called when an object goes out of scope or is deleted. However, if a user have taken over construction (using placement new) and destruction, a destructor must be explicitly called. Example. For example, explicit call of destructor is used in the implementation of standard librarycontainers. See also: placement new. TC++PL 10.4.11, E.3.1, D&E 10.5.1.

explicit constructor - constructor so that will not be used for implicit conversions. TC++PL 11.7.1.

explicit instantiation - explicit request to instantiate a template in a specific context. See also: template instantiation. TC++PL C.13.10, D&E 15.10.1.

explicit qualification - (1) by namespace name, see qualified name. (2) by template argument. TCP++L 13.3.2.

explicit type conversion - type conversion (explicitly) requested by the use of a C-style cast, new-style cast, or functional notation. See also, implicit type conversion, user-defined type conversion. TC++PL 6.2.7, D&E 14.3.2.

expression - combination of operators and names producing a value. TC++PL 6.2.

extended type information - any scheme that provides additional information base on the standard run time type information. TC++PL 15.4.4.1, D&E 14.2.5.2.

extension - see language extension

extern - a keyword used to indicate that the definition of an entity being declared is defined elsewhere. Because "extern: is only necessary for global variables it is largely redundant.

extracter - an iostream>> (put to) function. TC++PL 21.2,21.3, D&E 8.3.1.

facet - a class representing a primitive aspect of a locale, such as a way of writing an integer or a character encoding. TC++PL D.3.

false - boolvalue; converts to 0. TC++PL 4.2, D&E 11.7.2.

fat interface - an interface with more member functions and friends than are logically necessary. TC++PL 24.4.3.

field - see bitfield.

file - a sequence of bytes or words holding information in a computer. The term "file" is usually reserved to information placed on disk or elsewhere outside the main memory. The iostream part of the C++ standard library provides ifstream, ofstream, and fstream as abstraction for accessing files. TC++PL 21.5.

file stream - stream attached to a file. See also, fstream, ifstream, ofstream. TC++PL 21.5.1.

finally - a language construct supporting ad hoc cleanup in some languages. Similar, but not identical to C++'s catch(...). Use the "resource acquisition is initialization" technique instead.

find() - standard library linear search algorithm for a value in a sequence. TC++PL 18.5.2.

find_if() - standard library linear search algorithm for an element meeting a search criterion in a sequence. TC++PL 18.5.2.

float - single-precision floating-point number. TC++PL 4.5.

floating-point literal - the source text representation of a floating point value. For example, 0.314e1. TC++PL 4.5.1.

floating-point type - a float, double, or long double. A floating-point number is typically represented as a mantissa and an exponent. TC++PL 4.5.

for-statement - iterationstatement specifying an initializer, an iteration condition, a "next-iteration" operation, and a controlled statement. TC++PL 6.3.3.

free store - memory allocated by new; also called dynamic memory. Often standard library facilities, such as vector, can be used to avoid explicit use of free store. TC++PL 6.2.6, 10.4.3, D&E 2.11.2, 11.4.2.

free() - C standard deallocation function. Use delete instead.

free-standing function - a function that is not a member function. Useful for decreasing coupling between representation and algorithm. TC++PL 7, 18.

friend - a function or class explicitly granted access to members of a class by that class. TC++PL 11.5, C.11.4, D&E 2.10, 3.6.1-2.

friend function - a function declared as friend in a class so that it has the same access as the class' members without having to be within the scope of the class. And, no, friends do not "violate encapsulation". TC++PL 11.5, 11.2.3, C.11.4, D&E 2.10, 3.6.1.

front-end - the parts of a compiler that perform lexical and syntax checking, type checking, and initial semantic checking of a translation unit. Typically all compiler error messages comes from the front-end. See also: back-end. D&E 3.3.

front_inserter() - returns an iterator that can be used to add elements at the front of the container . TC++PL 19.2.4.

fstream - a file stream for input and output.

function - a named sequence of statements that can be invoked/called given arguments and that might return a value. The type of the function includes the number and types of argument and the type of the value returned, if any. See also: function declaration, function body. TC++PL 2.3, 7, D&E 2.6.

function argument - an argument to a function.

function body - the outermost block of a function. See also: try-block, function definition. TC++PL 2.7, 13.

function declaration - declaration of a function, including its name, argumenttypes, and return type.

function definition - function declaration including a function body.

function member - see member function.

function object - object with the applicationoperator, operator()(), defined so that it can be called like a function. A function object is more general than a function because it can hold data and provide additional operations. Sometimes called a functor. Given current compiler technology, simple function objects inline better than pointers to functions, so that parameterization with function objects can be far more efficient than use of pointers to functions or virtual functions. See also: binder, adapter, inlining. Example. TC++PL 18.4.

function parameter - a parameter of a function.

function prototype - C term for a function declaration that isn't also a function definition. D&E 2.6.

function template - see template function.

function try-block - try-block associated with the outmost block of a function, the function body. TC++PL 3.7.2.

functor - see function object.

G++ - see GNU C++.

garbage collection - techniques for reclaiming unused memory without relying on user-supplied delete or free() commands. A permitted but not required technique for C++. Commercial and free garbage collectors exist for C++: See my C++ page. Use of classes that control their own storage, such as the standard libraryvector, string, and map, reduces the need for garbage collection. See also: resource acquisition is initialization, destructor. TC++PL C.9.1. D&E 10.7.

general-purpose programming language - (1) a programming language intended for use in a wide range of application areas without restrictions that make it totally unsuitable for traditional major uses of computers, such as mathematical computations, data processing, text processing, graphics, and communications. (2) a language that can do what at least as much as other languages called "general purpose" can do. See also: C++.

generic programming - programming using templates to express algorithms and data structures parameterized by data types, operations, and polices. See also: polymorphism, multi-paradigm programming. TC++PL 2.7, 24.4.1, D&E 15.11.2.

get function - see >>.

global data - data defined in the global scope. This is usually best avoided because a programmer can't easily know what code manipulates it and how. It is therefore a common source of errors. Global constants are usually ok.

global scope - the scope containing all names defined outside any function, class, or namespace. Names in the global scope can be prefixed by ::. For example, ::main(). TC++PL 2.9.4.

glossary - "collection of glosses; lists and explanations of special words." - The Advanced Learners Dictionary of Current English. A pain to compile.

GNU C++ - GNU's implementation of C++.

goto - the infamous goto. Primarily useful in machine generated C++ code. TC++PL 6.3.4.

grammar - a systematic description of the syntax of a language. The C++ grammar is large and rather messy. Some of the syntactic complexity was inherited from C. TC++PL A, D&E 2.8.

GUI - Graphical User Interface. There are many C++ libraries and tools for building GUI-based applications, but no standard C++ GUI.

handle - an object that controls access to another. Often, a handle also controls the acquisition and release of resources. A common use is for a handle to control access to a variably-sized data structure. See also: resource acquisition is initialization, vector, string, smart pointer. TC++PL 25.7, D&E 11.5.2.

handle class - a small class that provides interface to an object of another class. A handle is the standard way of providing variable sized data structures in C++. Examples are string and vector. TC++PL 25.7.

handler - see exception handler

hash_map - hashed contained based on the standard library framework. Not (yet) part of the standard but very common in libraries based on the standard library. See also: map, vector, list. TC++PL 17.6.

header - see header file

header file - file holding declarations used in more than one translation unit. Thus, a header file acts as an interface between separately compiled parts of a program. A header file often contains inline function definitions, const definitions, enumerations, and template definitions, but it cannot be #included from for than one source file if it contain non-inline function definitions or variable definitions. TC++PL 2.4.1, 9.2.1. D&E 2.5, 11.3.3.

hiding - see information hiding

hierarchy - see class hierarchy.

higher-order function - functions that produce other functions. C++ does not have general higher-order functions, but by returning function objects a function can efficiently emulate some techniques traditionally relying of higher-order functions. See also: binder. TC++PL 18.4.4.

history of C++ - The work on what became C++ started by Bjarne Stroustrup in AT&T Bell Labs in 1979. The first commercial release was in 1985. Standards work stared in 1990 leading to ratification of the ISO standard in 1998. TC++PL 1.4. D&E Part 1.

Hungarian notation - a coding convention that encodes type information in variablenames. Its main use is to compensate for lack of type checking in weakly-typed or untyped languages. It is totally unsutable for C++ where it complicates maintenance and gets in the way of abstraction.

hybrid language - derogative term for a programming language that supports more programming styles (paradigms) rather than just object-oriented programming.

I/O - see iostream

IDE - Integrated (or Interactive) Development Enviornment. A software development environment (SDE) emphasizing a GUIinterface centered around a source code editor. There are many IDEs for C++, but no standard SDE.

identifier - see name.

if-statement - statement selecting between two alternatives based on a condition. TC++PL 6.3.2.

ifstream - an file stream for input.

implementation defined - an aspect of C++'s semantics that is defined for each implementation rather than specified in the standard for every implementation. An example is the size of an int (which must be at least 16 bits but can be longer). Avoid implementation defined behavior whenever possible. See also: undefined. TC++PL C.2.

implementation inheritance - see private base.

implicit type conversion - conversion applied implicitly based on an expected type and the type of a value. See also, explicit type conversion, user-defined type conversion. TC++PL 11.3.3, 11.3.5, 11.4, C.6, D&E 2.6.2, 3.6.1, 3.6.3, 11.2.

in-class - lexically within the declaration of a class. TC++PL 10.2.9, 10.4.6.2.

include - see #include.

incomplete type - type that allows an object to be copied, but not otherwise used. A pointer to an undeclared type is the typical example of an incomplete type.

inequality operator - see !=.

infix operator - a binary operator where the operator appears between the operands. For example, a+b.

information hiding - placing information where it can be accessed only through a well-defined interface. See also: access control, abstract class, separate compilation. TC++PL 2.4.

inheritance - a derived class is said to inherit the members of its base classes. TC++PL 2.6.2, 12.2, 23.4.3.1, D&E 3.5, 7.2, 12.

initialization - giving an object an initial value. Initialization differs from assignment in that there is no previous value involved. Initialization is done by constructors.

initializer list - comma-separated list of expressions enclosed in curly braces, e.g. { 1, 2, 3 } used to initialize a struct or an array. TC++PL 5.2.1, 5.7, 11.3.3.

inline function - function declared inline using the inline keyword or by being a member function defined in-class. Compilers are encouraged to generate inline code rather than function calls for inline functions. Most benefits from inlining comes with very short functions. TC++PL 7.1.1, 9.2, 10.2.9, D&E 2.4.1 .

inlining - see inline function.

input - see iostream.

inserter - (1) an iostream<< (put to) function. (2) an STL operation yielding an iterator to be used for adding elements to a containter. TC++PL 19.2.4, 21.2, D&E 8.3.1. See also: extracter, back_inserter, front_inserter.

instantiation - see template instantiation.

int - basic signed integer type; its precision is implementation-defined, but an int has at least 32 bits. TC++PL 2.3.1, 4.4.

integer type - a short, int, or long. Standard C++ doesn't support long long. TC++PL 4.4.

integral type - a bool, character type, or integer type. Supports arithmetic and logical operations. TC++PL 4.1.1.

interface - a set of declarations that defines how a part of a program can be accessed. The public members and the friends of a class defines that class' interface for other code to use. A class without data members defines a pure interface. The protected members provide an additional interface for use by members of derived classes. See also: abstract class.

interface function - A function that can access the representation of a class. See also: friend, member function, derived class, protected.

interface inheritance - see abstract class, public base.

invariant - a condition of the representation of an object (the object's state) that should hold each time an interface function is called; usually established by a constructor TC++PL 24.3.7, E.3.5.

iostream - (1) standard library flexible, extensible, type-safe input and output framework. (1) stream that can be used for both input and output. See also: file stream, string stream. TC++PL 3.4, 3.6, 21, D&E 3.11.4.1, 8.3.1.

ISO - the international standards organization. It defines and maintains the standards of the major non-proprietary programming languages, notably C++.

ISO C - see C.

ISO C++ - C++.

istream - inputstreamtype. TC++PL 3.6, 21.3.

istringstream - a string stream for input.

iteration - traversal of data structure, directly or indirectly using an iteration-statement. See also: recursion. The standard library offer algorithms, such as copy() and find(), that can be effective alternatives to explicit iteration. TC++PL 6.3.3. 18.

iteration-statement - for-statement, while-statement, or do-statement.

iterator - a standard libraryabstraction for objects referring to elements of a sequence. TC++PL 3.8.1, 19.2-3.

K&R C - C as defined by Kernighan and Ritchie.

Kernighan - Brian Kernighan is a co-author of Kernighan & Ritchie: "The Cprogramming Language".

Koenig lookup - see argument-based lookup.

language extension - (1) relatively new feature that people haven't yet gotten used to. (2) proposed new feature. (3) feature provided by one or more implementations, but not adopted by the standard; the use of some such features implies lock-in to a particular compiler supplier.

learning C++ - focus on concepts and techniques. You don't need to learn C first. See also "Learning Standard C++ as a New Language", available from my papers page. How do I start?. TC++PL 1.2, 1.7, D&E 7.2.

Library TR - technical report from the ISO C++ standards committee defining a set of new standard library components, including regular expression matching (regexp), hashedcontainers (ordered_map), and smart pointers. See my C++ page.

line comment - comment started by // and terminated by end-of-line. TC++PL 6.4, D&E 3.11.1.

linkage - the process of merging code from separately compiledtranslation units into a program or part of a program. TC++PL 9.

linker - the part of a C++ implementation that merge the code generated from separately compiledtranslation units into a program or part of a program. TC++PL 9.1, D&E 4.5, 11.3.

Liskov Substitution Principle - designclasses so that any derived class will be acceptable where its base class is. C++public bases enforce that as far as the interface provided by the base class. TC++PL 24.3.4, D&E 2.10.

list - standard library linked container. See also: vector, map. TC++PL 3.7.3, 17.2.2.

literal - notation for values of bool, character types, integer types, or floating-point types. See also: enumerators. TC++PL 4.2, 4.3.1, 4.4.1, 4.5.1, 5.2.2, D&E 11.2.1.

local class - class defined within a function. Most often, the use of a local class is a sign that a function is too large. Beware that a local class cannot be a valid template argument.

local function - function defined within a function. Not supported by C++. Most often, the use of a local function is a sign that a function is too large.

locale - standard libraryclass for representing culture dependencies relating to input and output, such as floating-point output formats, character sets, and collating rules. A locale is a container of facets. TC++PL 21.1, D.

long double - extended-precision floating-point number. TC++PL 4.5.

long int - integer of a size greater than or equal to the size of an int. TC++PL 4.4.

loop - a statement that expresses the notion of doing something zero or more times, such as a for-statement and a while-statement.

LSP - see Liskov Substitution Principle.

lvalue - an expression that may appear on the left-hand side of an assignment; for example, v[7] if v is an array or a vector. An lvalue is modifiable unless it is const. TC++PL 4.9.6, D&E 3.7.1.

macro - facility for character substitution; doesn't obey C++scope or type rules. C++ provides alternatives to most uses of macros; see template, inline, const, and namespace. Don't use macros unless you absolutely have to. TC++PL 7.8, D&E 2.9.2, 4.4, 18.

main() - the function called by the system to start a C++program. TC++PL 3.2, 6.1.7, 9.4 .

maintenance - work on a program after its initial release. Typical maintenance activities includebug fixing, minor feature enhancements, porting to new systems, improvements of error handling, modification to use different natural languages, improvements to documentation, and performance tuning. Maintenance typically consumes more than 80% of the total effort and cost expended on a program.

malloc() - C standard allocation function. Use new or vector instead.

map - standard library associative container, based on "less than" ordering. See also: hash_map, vector, list. TC++PL 3.7.4, 17.4.1.

Max Munch - (1) mythical participant in the C++ standards process. (2) the rule that says that while parsing C++ always chooses the lexically or syntactically longest alternative. Thus ++ is the increment operation, not two additions, and long int is a single integer type rather than the long integer followed by an int. Cross references in this glossary follow this rule.

member - type, variable, constant, or function declared in the scope of a class. TC++PL 5.7, 10.2, D&E 2.3, 2.5.2, 2.11.

member class - a class that is a member of another; also called a nested class. TC++PL 11.12, D&E 3.12, 13.5.

member constant - const or enumeration declared as a member. If initialized in-class, such a constant can be used in constant expressions within the class. TC++PL 10.4.6.2.

member data - see data member.

member function - a function declared in the scope of a class. A member function that is not a static member function must be called for an object of its class. TC++PL 10.2.1, D&E 2.3, 3.5.

member initializer - initializer for a member specified in the constructor for its class. TC++PL 10.4.6, 12.2.2, D&E 12.9.

member type - member class, member enumeration, or member typedef.

memberwise copy - copying a classobject by copying each of its members in turn, using proper copy constructors or copy assignments. That's the default meaning of copy. TC++PL 10.4.4.1, 10.4.6.3, D&E 11.4.4.

memory - static memory, stack, or free store.

memory management - a way of allocating and freeing memory. In C++ memory is either static, allocated on the stack, or allocated on the free store. When people talk about memory management, they usually think of free store or even specifically about garbage collection. Memory can often be effectively managed through standard librarycontainers, such as vector or string, or through general resource management techniques. See also: auto_ptr, constructor, destructor, resource acquisition is initialization. TC++PL C.9, D&E 3.9, 10.

mem_fun() - an adapter that allows a member function to be used as an argument to a standard algorithm requiring a free-standing function. TC++PL 18.4.4.2.

method - see virtual member function.

Microsoft C++ - see Visual C++

modifiable lvalue - lvalue that is not const. TC++PL 4.9.6.

most-derived type - the type used to create an object (before any conversions). See also: dynamic type, static type.

multi-method - a virtualfunction that selects the function to be called based on more than one operand. See also: multiple dispatch. D&E 13.8.

multi-paradigm design - design focussed on applying the various paradigms to their best advantage. See also: multi-paradigm programming.

multi-paradigm programming - programming applying different styles of programming, such as object-oriented programming and generic programming where they are most appropriate. In particular, programming using combinations of different programming styles (paradigms) to express code more clearly than is possible using only one style. See also: C++.

multimap - map that allows multiple values for a key. TC++PL 17.4.2.

multiple dispatch - the generalization of double dispatch to more operands. See also: single dispatch.

multiple inheritance - the use of more than one immediate base class for a derived class. One typical use is to have one base define an interface and another providing help for the implementation. TC++PL 12.2.4, 12.4, 15.2.5, D&E 12.

mutable - an attribute of a member that makes it possible to change its value even if its object is declared to be const TC++PL 10.2.7.2, D&E 13.3.3.

name - sequence of letters and digits started by a letter, used to identify ("name") user-defined entities in program text. An underscore is considered a letter. Names are case sensitive. The standard imposes no upper limit on the length of names. TC++PL 4.9.3.

namespace - a named scope. TC++PL 2.5.1, 8.1, C.10. D&E 17.

namespace alias - alternative name for a namespace; often a shorter name. TC++PL 8.2.7, D&E 17.4.3.

NCITS - National Committee for Information Technology Standards. The part of ANSI that deals with programming language standards, notably C++, and sells copies of the C++ standard. Formerly known as X3.

nested class - see member class.

nested function - see local function.

new - object creation operator. See also: constructor, placement new, operator new(), resource management, memory management, garbage collection. TC++PL 6.2.6, 19.4.5, D&E 2.3, 10.2.

new-style cast - dynamic_cast, static_cast, const_cast, or reinterpret_cast. D&E 14.3.

new_handler - a (possibly user-defined) function called by new if operator new() fails to allocate sufficient memory. See also: std::bad_allocexception. TC++PL 6.2.6.2, 14.4.5., 19.4.5.

If you're interested in the semantics of search, Google's announcement this week that it is now bolding synonyms in search results probably turned your head. (In fact, you might have noticed this happening before the official announcement.)

In a post titled "Helping Computers Understand Language" on the Official Google Blog, Google engineer Steven Baker writes:

An irony of computer science is that tasks humans struggle with can be performed easily by computer programs, but tasks humans can perform effortlessly remain difficult for computers.

I don't know if I'd call this an irony. Humans are better at some things, computers are better at others. You can say the same thing about bees, buzz saws, and evolution. But identifying misuses of the word "irony" is so 1996, so let's move along. The point is, Google wants computers – search engines, specifically – to understand human language better. And it's collected so much search query and user behavior data that it's getting closer to that goal:

The goal of a search engine is to return the best results for your search, and understanding language is crucial to returning the best results. A key part of this is our system for understanding synonyms […] our measurements show that synonyms affect 70 percent of user searches across the more than 100 languages Google supports. We took a set of these queries and analyzed how precise the synonyms were, and were happy with the results: For every 50 queries where synonyms significantly improved the search results, we had only one truly bad synonym.

It's hard to argue with hard data; if the results are highly relevant 98% of the time then it makes sense to (prominently) include pages with synonyms. Probably, I do not represent the average user of Google, but I feel like I often fall in that unlucky 2% – getting results that are not what I wanted. (Of course, Google kind of covers its ass with that "truly"; maybe what I consider to be bad results are not truly bad.)

Take this search, which I performed on 1/4/10:

I was looking specifically for a page on our site about Google ads, but Google interpreted "ads" as a synonym for "AdWords." Um. This seems wrong to me. Yes, Google AdWords serves up Google ads … but to me the phrases mean totally different things. AdWords is an advertising platform. "Ads" refers to the individual advertisements. Occasionally, I'll run a search and Google will ask me, "Did you mean X?" and I'll wish I had the option of telling it, "NO, I didn't, actually!" (Wouldn't that data be useful to them?) But in this case (and presumably this is true for all results with synonyms), I don't even see that prompt.

What are others saying about Google's new synonym policy?

Andy Beal of Marketing Pilgrim takes issue with Google's longwinded announcement ("If Google’s explanation of its code is anything like its actual code, it must be very bloated!"), but thinks "it’s actually a pretty smart piece of technology."

In a comment on his own wrap-up post on SEO by the Sea, Bill Slawski remarks that "for every 50 queries they only had one 'truly' bad synonym – even though that’s a small number, in context it’s still a lot of searches. I hope they find a way to reduce that number to a much smaller percentage." Agreed.

Jamie Forrest focuses on Google's professed method of improving the accuracy of these results—not by fixing bad synonyms by hand, as Baker said, but by trying "to discover general improvements to our algorithms to fix the problems." Forrest writes:

I infer from this that Google doesn’t typically fix any bad search results by hand. They would much rather fix the underlying algorithm than hard code a bunch of corner cases. […] At first glance you might think that Google makes this choice because it’s right architecturally–because it’s cleaner and easier [to] maintain. But I think the bigger reason is that Google cannot be seen to be tipping its hand.

Matt McGee calls attention to some power user search tips to turn off synonyms (good to know!) or force additional synonyms:

The official post also mentions that users can turn off synonyms by putting a plug sign (+) before a word in your query, or by putting the query in quotation marks.

Not mentioned in either post is that you can use the tilde symbol (~) to force Google to show additional synonyms (and related words) for your query. For example, a search for [~murder statistics] leads Google to bold words like “crime,” “crime statistics,” “suicide statistics,” “criminal,” and more.

On Search Engine Watch, Nathania Johnson notes that "SEO copywriters would be diligent to consider the possibility of expansion of synonyms should Google like how their new feature plays out among searchers." I wonder, though, if this move will actually make inclusion of synonyms less important for copywriters. If a page on developing photos in coffee (what's that all about anyway?) will now capture search traffic for the query "pictures developed in coffee," maybe you don't have to worry about including the word "pictures" on the page? As Google's synonym algorithm gets smarter, the synonym part of keyword research might be simplified.

Other Highlights from the Week

A few more posts worth pointing your eyes at:

  • Speaking of copywriting, Giovanna at PPC Blog delivers a meaty post on PPC copywriting, claiming that "there's a lot of nonsense written about copywriting" and the most important factor in copy that sells is making "the right offer to the right audience." She offers some great tips for understanding your market and who you're competing against.
  • Over at Search Engine Journal, Julie Joyce shares some thoughts about purple prose and link building—specifically, your prose should not be purple if what you want is to grab people's attention and generate a link. It should be brief, clear, and to the point.
  • On Techipedia, guest poster Samir Balwani asks "Is Social Media Worth it for You?" He says that some industries, like restaurants and online companies, can see a big return from investment in social media, but other businesses, like those based on impulse buys, won't find it to be a viable strategy.
  • In a guest post on Search Engine Land, George Michie says "The Pundits Are Wrong! Don’t Cut Off Your Tail." He argues that broad match is no substitute for long-tail keyword marketing, especially for large-scale paid search campaigns.

Have a good weekend!

Categories: 1

0 Replies to “Assignment Operator Could Not Be Generate Synonyms”

Leave a comment

L'indirizzo email non verrà pubblicato. I campi obbligatori sono contrassegnati *