C versus C++:
C++ object oriented, message based, event driven. C++ is a superset of C. Most C programs are C++ (additional libs and new '//' comment type,operator overloading '>>').
C++ is Object-Oriented. In C++:
- void is optional int f(); is equal to int f(void);
- All functions must be prototyped.
- A character constant is NOT automatically elevated to an integer.
- It is an error to declare a global variable several times.
- There is no identifier character length limit
Memory Regions: A C/C++ program uses four logical regions of memory.
- Code region: The region that actually holds the code.
- Global Varibale region
- Stack: Holds the return adress of function calls, arguments to functions, and local variables,
also used to save the current state of the CPU.
- The heap is a region of free memory for dynamic allocatinos like malloc.
Access Modifiers: used to control the ways in which variables maybe accessed or modified.
- Const: constant type variables may not be changed during execution by program, can be initialized only.
- Volatile: is used to tell the compiler that a variable's value can be changed in many ways ( outside the program by operating
system or hardware) explicitly specified by the program. this is important because compiler might think this variable
is never changed inside an expression and it can be optimized by changing the order of that expression. volatile modifier
prevents these changes from occurring.
Storage Class Modifiers:
- Extern: lets the compiler know what the types and names are for these global variables without actually
creating storage for them. Extern statements are declarations but not definitions.
- Static: permanent variables within their own function or file and maintain their values between calls.
Static local variable is like a global variable with the difference of it is visible within its own block. Retains value.
Static local variables are only initialized once. All globals are initialized to 0. All local and register variables that
are not initialized will have unknown values before the first assignment to them.
Static global variables are known only within the file.
- Register variables are stored in CPU register if possible. Faster. Ideal for loop control. they are best
to be used where many references will be made to the same variable. If more register variable are declared than CPU registers,
compiler will pick the most needed.
Object: is a logical entity containing data and code. Encapsulation. Variable of user defined type. Links
both code and data.
Polymorphism: Allows on name to be used for several related but different purposes. Sometimes characterized
by "one interface, multiple methods". The compiler selects the the correct routine depending on the data type
which is called. C++ supports polymorphism at both run-time and compile time. Function Overloading and Operator overloading
are (early binding) compile-time Polymorphism. Derived classes and virtual functions are (late binding) run-time polymorphism.
Early binding (compile time polymorphism) advantage is faster and efficient code but less flexibility. Advantage of late binding
(run-time polymorphism) is flexibility but slower and less efficient code)
Polymorphism helps building hierarchies gong from general to specialized. figure -> triangle, square.
Inheritance: is the process by which one object can acquire the properties of another object. Apple-Reddelicious
apple. Allowing one class to incorporate another class into its declaration.
Function Overloading: Polymorphism is achieved by. More than one function can have the same name as long
as they have different parameter declaration.
Operator Overloading: Operators are overloaded in .h files. Eg: >> or a class that defines a linked
list might use the + operator to add an object to the list. Operator functions must be either members or friends of the
class for which they are being used.
Class: General form an object. Similar to Structure (A new data type). Containes private(default) and
public parts. Functions are called member functions.
C++ struct and class are actually the same except that by default members of a class are private while by default the
members of a struct are public. C++ struct can have data, code ,construct and destruct funcs.
Union: C++ unions are the same as classes too. A union is essentially a structure in which all elements are stored in the same
location. C++ unions have one additional feature called anonymous union.
- Anonymous union:is a union that has neither a tag name nor any
variables specified in its declaration. The names of the members are accessed directly without using any form of the dot
or arrow operator. Global anonymous unions must be classified as static. Anonymous unions can not include private or protected
elements.
This keyword: each time a member function is invoked, it is automatically passed a pointer to the object
that invoked it. You can access this pointer using this. this->i= val.
Inheritance:
| Child (derived) |
Inherit |
Parent (Base) |
|
|
|
| public |
public |
public |
|
class c1 {
int v1;int v2, v3;
public:
c1 (int i1);
~c1 (void);
void f1(int i);
friend f2 (int i);
};
void c1::f1(int i) {
...
}
|
class c2: public c1 {
public:
friend f2 (int i);
...
} |
| protected |
|
protected |
|
| ---- |
|
private |
|
| private |
private |
public |
|
| private |
|
protected |
|
| ---- |
|
private |
|
| |
|
|
|
Scope Resolution: object.classtype::var
Constructor: is a special function that has the same name as the class and called when the object is created.
Destructor when destroyed. Constructors are executed starting from base to derived, and destructor in the opposite direction. Both
can be overloaded. Multiple base class constructors are called left to right, destructors right to left.
Public:
Private:
Protected:
Virtual: run-time polymorphism.is a function that is declared as virtual in a base class and redefined
in one or more derived classes. Selection of which derived virtual function to call at run-time is based on the type of
the object pointed to. Although you could call a virtual func directly using the object name same as any other member function,
run-time polymorphism is achieved only if a virtual function is accesed through a pointer to base class.
Redefinition of virtual func is a special form of func overloading but with some restrictions. prototypes of virt funcs must
match. Also a virtual func must be a member not a friend, of the class for which it is friend. However a virtual fu nc can be
a friend of another class. Also destructors can be virtue , but constructors cant. So the term overriding is used for virtue
funcs rather than overloading. Once a func is declared virtual, it st ayes virtual no matter how many layers of derived classes
it can pass through. When a derived class does not override a virtual func, the version of the func in the base class is used.
Pure Virtual function is a function declared in a base class that has no definition relative to the base.
So all derived classes must define its own version. By declaring a virtual fu nc as pure, you force any derived class to define
its own implementation type f(parlist) =0;
Virtual Base Classes: When two or more objects are derived from a common base class, you can prevent multiple
copies of the base class from being presented in an object derived rom those objects by declaring the base class as virtual
when it is inherited/ Virtual and base classes differ only when an object inherits the base more than once. When virtual
base classes are used, only one base class present in the object. Otherwise multiple copies are found.
class base {...};; class d1: virtual public base {...}; class d2: virtual public base {...}; class d3: public d1, public
d2 {...}; Only one copy of base in d3
Abstract Class: if a class has at least one pure virtual fu nc that class is said to be abstract. There can
be no object of an abstract class. They can only be used as base class to be inherited can still use an abstract
class to declare pointers.
Friend: Allows a nonmember function of a class to have access to the private parts of the class. The nonmember
function is defined elsewhere and declared as friend in the pubic part so that this function can access the private part
of this class. the classes that has the friend function (except the last class as the referenced classes are deifned already)
must be forward referenced (class class_name;) as the friend function references those classes.
Remeber that friend functions are allowed in C++ mostly to handle some special-case operations.
Inline: is a function that is expanded at the point at which it is called instead of actually being called.
Like parameterized function-like macro in C but more flexible. Use inline functions for efficiency. no function call procedures,
No pushing and poping arguments into stack and returning from function. Faster speed, larger size. Prefer smaller functions
for inline. Two ways to create inline. with the inline keyword and inside a class.
Static Class Members: when a member of a class is declared as static, no matter how many objects are created,
there is only one copy of the static member. A static member is shared by all objects of the class. All static data is
initialized to 0 and no other initialization is allowed. When a Static member function is created only
one copy of it exists and used by all objects. Static member functions have access to all static data and other static
functions declare in a class, but o access to non static data and functions. Static functions don't have a this pointer
so there is no way of knowing which objects non static data or function to access. They don't really belong to an object
but the class they are declared.They can be used for automatic access protection mechanism to critical resources.
class c{ static int count; public: static void f () {} };
New and Delete: equalent of malloc() and free() in C. Advantages: no need to calculate the size of memory
to alloc(no need for size of). Also automatically returns the correct pointer type. Possible to initialize the object being
allocated using new. and new and delete can be overloaded(for example you may want allocation routines that automatically
begins using disk file as a virtual memory when the heap has been exhausted)..
Operator:
Local Variables: In C++ you can declare local variables anywhere within block of code as oppesed in C
you must declare all the local variables at the beginnig of a block. Helps encapsulation and localization of code
Dynamic Initialization: In C++ both local and global variables can be initialized at run-time. In C, a
variables initial value must be known at compile time requiring functions can not be used to initialize variables. Like variables,
objects can be initialized dynamically.
Optional function parameters: f (int a, int b=0) {...}; b does not have to be passed while calling f. Optional. Can be
passed though.
Call by reference:in C and C++ int x; f(&x); void f(int *a) {...}; equals in C++ int x; f(x); void
f(int &a);Cleaner. Compiler automatically generates the address of the argument used to call function and automatically
de references the calling variable. Can't reference a reference vary. cant create arrays of references, cant create pointer
to a reference, references are not allowed on bit fields.
Non parameter reference variables (independent or standalone references) ot a good idea but exists. int j,k; int &i
= j; j=10; cout << j << "" < i; outputs 10 10 Something like duplication of the same memory area
of a varible by another name. Must be initialised at declaration. Adress of a peviously declared varibale. i++ does not
caus to point to antoher address instead increses k by 1. References are not pointers.
Reference to overload a Unary operator The way to use a friend whenoverloading a unary ++ or -- is to use a refernece parameter. In this way compiler knows in advance that it must generate an address when it calls the function. This avoids the ambiguity introduced by trying to create a friend operator++() function. P. 806.
Linkage Specification:by using it you can cause a function written in a different languageto be linked
into your program. extern "C" void myfunc(void);Must be global cant be used inside a function.
void myfunc(void) {...}
Pointer-to-member operators .* and ->* : They allow you to access a member of a class given a pointer
to that member. These are neded beacuse a pointer to a member does not fully determine an adress. Instead, it provides
a n offsetinti an object of the member's class...
Conversion functions: You can use a type conversion functionto convert your class into a type compatible with that of the
rest of the experession that the object is used. class three_d { ... public: operator int() {return ...;} three_d b(..);
cout << b+100; object is used as an integer here and the value is an integer. double or long ...
Granting Access:If you want some of the public elements of the privately inhereted base class to be public, use access
declaration. class c1: private c2 { public: c2::i; ...}; Can be used for the protected eleemnts of thebase class too.
however status level can not be changed. private of base class can not be public in derived class, nor public base element
cannot be private in derived class.Shortly public can stay pubic no matter how the base is inhereted.
Backfire questions:
what is the diffrence between void f(void) and void f()
write a function to calculate c**a
int* a, b; This decleration creates one, not two, integer pointers. In C++ neither & nor * is transitive over a list
of variables. & and * arelinked to the individual variable that they precede, not to the type that they follow.
