COMP 206 Unit 9: Name Control

Frage	Antworten
static	1. allocated once at fixed address; object created in static data area 2. local to particular translation unit: - visibility: name cannot be seen outside translation unit/class - linkage: determines what names linker will see
static keyword for variables inside function	object is initialized only once, first time function is called, and then retains value between function invocations
static keyword for class objects inside function	- some initialization required for object - assignment to 0 has meaning only for built-in types; user-defined types must be initialized with constructor calls - class must have default constructor
static object destructor	destroys all objects with static storage; called when main() exits or when Standard C library function exit() is explicitly called -destruction occurs in reverse order -only constructed objects are destroyed - when main() exits, destructors for objects that have been constructed are called in reverse order of construction
auto	- indicates local variable - refers to way compiler automatically allocates storage for variable
register	indicates to compiler that object should be stored in machine register
namespace	- puts name of members in distinct space - declarative region that provides scope to identifiers
keyword namespace used to control linkage	- linkage describes how names can refer to same entity throughout whole program or single translation unit - names of global functions, global variables, and classes are still in single global namespace - subdivide global name space into more manageable pieces using namespace
external linkage	link time the name is visible to the linker everywhere, external to that translation unit
internal linkage	- local to translation unit - use same name in other translation units without name clash
creating namespace	- similar to creation of class - definition can appear only at global scope, or nested within another namespace - no terminating semicolon is necessary after closing brace of namespace definition - can be "continued" over multiple header files using syntax that, for a class, would appear to be redefinition
namespace example	namespace MyLib { // Declarations } int main() { }
steps in using namespace	- specifying name using scope resolution operator - using directive to introduce all names in namespace - using declaration to introduce names one at a time
using directive	- provides access to all namespace qualifiers and scope operators - apply using keyword to namespace identifiers
using declaration	- inject names one at a time into current scope - declaration within current scope
static data members vs global variables	- global data can be modified by anyone, and its name can clash with other identical names in large project - static data belong to class; its name is scoped inside class and it can be public, private, or protected
storage utilization for static data members	- storage must be defined in single place - definition must occur outside class and only one definition is allowed
initialize static array	- syntax for initializing static arrays is same as for any aggregate, including automatic counting - arrays, non-integral and non-const statics must be initialized externally
restrictions placed on static data members and local classes	- put static data members in classes that are nested inside other classes - cannot have static data members inside local classes
static member functions	- work for class as whole rather than for particular object of class; express association with particular class - only access static data members
steps to create and use static member function	- create function with static keyword in front of function name (e.g. static void f() {};) - call function with dot or arrow in association with object
Guarantees of order of creation/destruction of static objects	- order of initialization of static objects is guaranteed to be order in which object definitions appear in translation unit - order of destruction is guaranteed to be reverse of order of initialization - no guarantee concerning order of initialization of static objects across translation units - linking-loading mechanism guarantees static initialization to zero before dynamic initialization specified by programmer takes places
3 approaches to resolving problems from creation/destruction of static objects	1. avoid static initialization dependencies 2. put critical static objects definitions in single file 3. use programmatic techniques to scatter static objects across translation units
handling static objects using Technique 1	- requires additional class in library header file - class is responsible for dynamic initialization of library's static object - declarations for objects do not allocate storage - have pointers to objects and create them using new inside constructor
handling static objects using Technique 2	- static objects inside functions are initialized first time function is called - place static object function that returns reference to object -first time function is called, forces initialization to take place - define wrapping function in separate files
alternate linkage specification	- escape mechanism provided in C++ - produced in language by overloading extern keyword
using alternate linkage specification	- extern is followed by string that specifies linkage you want for declaration (e.g. extern "C" float f(int a, char b);) - groups declarations with alternate linkage inside braces or header file

Nächster

COMP 206 Unit 9: Name Control

Beschreibung

Zusammenfassung der Ressource

ähnlicher Inhalt

	Erstellt von Adriana Vincelli-Joma vor etwa 3 Jahre