changes

[docs.git] / langs / cpp.txt

                                                01jun00 17jul00 01jul03

Inheritance {{{

code example {{{2

#include <iostream>
#include <string>
using namespace std;

class Pet
{
public:
    // Constructors, Destructors
    Pet(): weight(1), food("Pet Chow") {}
    ~Pet() {}

    //Accessors
    void setWeight(int w) {weight = w;}
    int getWeight() {return weight;}

    void setfood(string f) {food = f;}
    string getFood() {return food;}

    //General methods
    void eat();
    void speak();

protected:
    int weight;
    string food;

};

void Pet::eat()
{
    cout << "Eating " << food << endl;
}

void Pet::speak()
{
    cout << "Growl" << endl;
}

class Rat: public Pet
{
public:
    Rat() {}
    ~Rat() {}

    //Other methods
    void sicken() {cout << "Speading Plague" << endl;}

};

class Cat: public Pet
{
public:
    Cat() : numberToes(5) {}
    ~Cat() {}

    //Other accessors
    void setNumberToes(int toes) {numberToes = toes;}
    int getNumberToes() {return numberToes;}

private:
    int numberToes;
};

int main()
{
    Rat charles;
    Cat fluffy;

    charles.setWeight(25);
    cout << "Charles weighs " << charles.getWeight() << " lbs. " << endl;
    charles.speak();
    charles.eat();
    charles.sicken();

    fluffy.speak();
    fluffy.eat();
    cout << "Fluffy has " << fluffy.getNumberToes() << " toes " << endl;

    return 0;
}

}}}2

Output of code example {{{2

Charles weighs 25 lbs.
Growl
Eating Pet Chow
Speading Plague
Growl
Eating Pet Chow
Fluffy has 5 toes

}}}2



 Possible to "clone" existing class to new one with exception that if the original class
 called base (or super or parent ) is changed,the modified "clone" ( called derived or
 inherited or child or sub ) also reflect those changes.
 To change the derived class possible by adding new member funcs or by changing 
 existing funcs ( called override ).
 If the derived class only override base class funcs ( and not to add new ) so
 because the interface will be the same will have almost the same class type.
 As a result possible to substitute object of the derived class with object of the base
 class. This substitution principle called pure substitution. 
 Adding new func to the derived class creating follow situation:
 This will expend interface but this new type will still be substitute for the base class,
 but substitution isn't perfect cause the new func doesn't accessible from base type.
 
}}}

Operator overloading{{{

Only existing operators can be overloaded.

}}}

run time type info (rtti) {{{1



}}}1


 Composition(Aggregation)
 Can put object of existing class as member of another class (creating member object).
 Also called "has-a" relationship.

4 Interchangeable objects with polymorphism 
 To write code that doesn't depent on specific type needs to treat object as its base
 type. The problem is that compiler can not know what code will be executed. The 
 answer is that compiler change traditional call.
 The non-OOP compilers generates func call called early binding ( compiler generate
 call to func name and linker resolve it to absolute address ). In OOP address of call
 can not be determine until runtime. The OOP compiler using late binding where
 compiler does ensure that func exists and perform type checking on args and
 return value. Actualy compiler place specified bit of code instead of address in place
 of adsolute code. 
 The proccess of treating a derived type as base type called upcasting. 
 
5 Creating and destroying objs
 For max runtime speed, the storage and lifetime can be determined while the program
 is being writen by placing the objs on the stack or in static storage. 
 Stack memory used directly by CPU to store data during program execution. Vars at 
 stack called automatic ( or scoped ). The static storage simply patch of memory before
 the program begins to run. 
 Possible to create objs dynamically in heap, using new keyword. In that you don't know
 how many objs you need, what there lifetime and what their exact type is. When you
 finish w/ storage must release using delete keyword.
 Because the heap storage managed dynamically at runtime, the amount of time
 required to allocate storage on the heap longer than to create storage on the stack.
 The lifetime of obj. If you create obj on stack or static storage the compiler determine
 how much obj will be alive and automatically destroyed it. When create obj at heap the 
 compiler doesn't know about them so programmer have to delete them. Additional
 exists feature called garbage collector. 

6 Declaration vs. Definition
 A declaration introduces a name - an identifier - to the compiler. It says to compiler 
 "this func or var exists somewhere and here is what it is should look like. 
 A definition says: "Make this var here". It allocates storage for the name and in the point
 of definition allocates storage. ???

7 Funcs declaration and definition
 int func1( int len1,int len2) 
 Arguments in declaration may have names, but compiler ignores them. The func decla-
 ration w/o args int func2() gives in C meaning of func w/ any number and type of args and
 in C++ func w/o args. Definition looks like declaration but have a body.
 
8 Var declaration and definition
 extern int i;                    // declaration w/o definition
 extern float f(float);      // func declaration

 float b;                          // declaration & definition
 float f(float a) {            // definition
   return a+1;
 }

 int i;                              // definition
 int h(int x) {                 // declaration & definition
   return x+1;
 }

 int main () {
   b = 1;
   i = 2;
   f(b);
   h(i);
 }

9 Headers
 The librarys inherired from C still available in traditional ".h" extension, but possible
 to use them in C++ style by prepending a "c" before the name, like instead of
 #include <stdlib.h>     will be         #include <cstdlib>
 The difference is that using header w/ ".h" gives older non-template version of header
 file and w/o ".h" gives new template version. Problem to mix them.
 
10 Linker
 When linker found external reference to a func or a var : if it not already encountered
 definition it adds identifier to its list of "unresolved references" oposite the reference
 is solved.
 First linker search in objs and if not find start search at libraries. Libraries have some
 sort of indexing so linker looking for the library obj that contents definition of reference
 and linked it to executable ( only the obj that content definition not whole library ).
 If want to minimize exe file just put single funs in each source code file when build
 own library. 
 Because linker searches files in order you give them , possible to pre-empt the use
 of a library func by inserting a file w/ your own func, using the same func name, into
 the list before library name appears. So linker would find the definition from your file
 before going to library.
 There are additional items added  to exe file in linking. One of them is startup module,
 contents init routines that must be run any time a C/C++ program executed. These 
 routines set up stack and init certain vars.
 Linker searches "standard" funcs in standard library, so just add header file for
 certain funs. In case of add-on library needs to add library filename to linker.

11 Namespaces
To prevent colisions of func or var name C++ have keyword namespace.
Each set of C++ definitions in library or program "wrapped" in a namespace,
so if other definition has identical name in a different namespace - no colision.
Foolow code should be use:
using namespace std;
This is expose all names from namespace, but only those for current file.

12 Introducing strings, read and write files, vector
String manipulation simple case of string class exists in C++.
Just add 
#include <string>
string s1,s2;
string s3 = "Hello";
string s4("I am");

s2 = "Today";
s1= s3 + " " + s4;
s1 += " 8 ";
cout << s1 + s2 + "!" << endl;
and will output:
Hello I am 8 Today!
Files.
To open file just add <fstream>. This is automatically include <iostream>.
So to open file for reading creates obj fstream that behaves like cin and for
open writing obj ofstream behaves like cout.
There is func getline() which reads one line (terminated by newline) from ifstream.
This is example to copy one file into another:
#include <string>
#include <fstream>

int main () {
 ifstream in("Scopy.cpp");       // open for read
 ofstream out("Scopy2.cpp"); // open for write
 string s;
 while(getline(in,s))     // newline discard and not copy to s
  out << s << "\n";

Another example is copy whole file into string:
#include <string>
#include <iostream>
#include <fstream>
using namespace std;

int main () {
 ifstream in("Scopy.cpp");       // open for read
 string s, line;
 while(getline(in,line))     // newline discard and not copy to s
        s += line + "\n";
 out << s;

Vector.
In case of reading file into string obj problem to know how many string objs
needs cause this will known only after reading whole file.
The class vector solved it. This is template ,means, can be applied to different
types, like vector of strings:  vector<string>
It's also content all array behavior.Example of reading file and add line numbers:
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

int main () {
 vector<string> v;
 ifstream in("Scopy.cpp");       // open for read
 string line;
 while(getline(in,line))     // newline discard and not copy to s
        v.push_back(line);   // add line to the end
 for( int i=0; i< v.size() ; i++)    // i less than number of elements of v
        cout << i << ": " << v[i] << endl;

There is example how to break a file into whitespace-separated words:
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

int main () {
 vector<string> v;
 ifstream in("Scopy.cpp");       // open for read
 string word;
 while( in >> word)     // gets one word at a time 
        v.push_back(word);   // add line to the end
 for( int i=0; i< v.size() ; i++)    // i less than number of elements of v
        cout << v[i] << endl;








Creating function
declaration prototype:  float func(float ,float, float);

Controlling execution
#include <iostream>
using namespace std;

int main() {
 int i;
 cout <<"type number"<<endl;
 cin>>i;
 if(i>5) cout << "greater than 5" << endl;
 else if (i=5) cout << "equal to 5" << endl;
 else cout << "less tyhan 5" << endl;
}
                        While
#include <iostream>
using namespace std;

int main() {
 int secret = 15;
 int guess = 0;
 
 while( guess != secret )
   cout << "guess number:";
   cin >> guess;
 }
 cout << "Right!!!" << endl;
}
        Do-while , For , Break and Continue
#include <iostream>
using namespace std;

int main() {
 char c;
 while (true) {
  cout << "main menu:" << endl;
  cout << "l: left; q: quit; -> ";
  cin >> c;
  if (c == 'q') break; // out of while
  if (c == 'l') {
   cout << "Left menu:" << endl;
   cout << "Slect a or b";
   cin >> c;
   if (c == 'a') {
    cout << "Choosen 'a'" << endl;
    continue;  // Back to Main Menu
   }
   if (c == 'b') {
    cout << "Choosen 'b'" << endl;
    continue:  // back to Main Menu
   }
   else {
    cout << "Wrong choose" << endl;
    continue;  // back to Main Menu
   }
  }
  cout << "Must choose l or q" << endl;
 }
 cout << "quiting . . ." << endl
}
                        Switch
switch(selector) {
        case integral_value1: statement; break;
        . . .
        default: statement;
}
It's requires a selector that evaluates to an integral value
at compile time, so string object as a selector won't work.
                        Recursion
#include <iostream>
using namespace std;

void removeHat(char cat) {
 for (char c = 'A'; c < cat; c++)
  cout << " ";
 if(cat <= 'Z') {
  cout << "cat " << cat << endl;
  removeHat(cat +1);
 } 
 else cuot << "Voom!!!" << endl;
}

int main() {
 removeHat ('A');
}

Introduction to data types
                        Basic data types.
There are 4 basic data types: int , char , float , double.
                        Bool , true and false.
The standard C++ bool type have two states by the built-in constants true 
( integral one) and false ( integral zdero ). Compiler will implicitly convert 
from an int to a bool ( nonzero values will produce true ).
The use of ++ (increment) to set a flag to true still allowed but deprecated. 
The problem is that it's making implicit type conversion from bool to int, 
incrementing the value and then implicitly converting it back again.
                        Specifiers.
They modifies meaning of basic types by expanding them.
here are 4: long , short , signed , unsigned.
                        Intro to pointers.
Every part of program have it location in memory, so we can get address
of that place. The operator & gives this possibily.
#include <iostream>
using namespace std;

int dog;

void f(int pet) {
 cuot << "Pet id:" << pet << endl;
}

int main() {
 int i;

 cout << "f() " << (long)&f << endl;
 cout << "dog: " << (long)&dog << endl;
 cout << "i: " << (long)&i << endl;
}

By results possible to see that vars defined in main() are in different area 
than the vars defined outside main().
                        Modifying outside obj.
#include <iostream>
using namespace std;

void f(int* p) {
 cout << "*p = " << *p << endl;
 *p = 5;
 cout << "*p = " << *p << endl;
}

int main() {
 int x = 47;
 cout << "x = " << x << endl;
 f(&x);
 cout << "x = " << x << endl;
}
                        Intro to C++ references.
Additional way to pass an address into a func is reference.
Changed last program to pass by reference.
#include <iostream>
using namespace std;

void f( int& p) {
 cout << "&p = " << &p << endl;
 &p = 5;
 cout << "&p = " << &p << endl;
}

int main() {
 int x = 47;
 cout << "x = " << x << endl;
 f(x);  // looks like pass-by-value but it's pass-by-reference
 cout << "x = " << x << endl;
}
                Pointer and reference as modifiers
All possible ombinations of basic data types , spicifiers, pointers and
references:
void f1(char c,int i,float f, double d);
void f2(short int si, long int li, long double ld);
void f3(unsigned char uc,unsigned int ui,unsigned short int usi,
        unsigned long int uli);
void f4(char* cp,int* ip,float* fp, double* dp);
void f5(short int* sip, long int* lip, long double* ldp);
. . .
Pointer to void type means that it is pointer to any data type.
There is no reference to void.

Scoping
Scope of var extends from the point it defined to the first closing brace.So a scope is defined by its "nearest" set of braces.
                Defining vars on the fly.
C++ gives to define var anywhere in a scopeeven right before use. Possible to define var inside the control expressions of for and while loops,inside the conditional of an if 
statement and inside the selector statement of a switch.

Specifying storage allocation
                        Global vars
Defines outside all function bodies and are available to all parts of the
program even in other files. If existence of a global var in one file is 
declared using the extern keyword ni other file , the data is available for
use in second file.
// global.cpp
#include <iostream>
using namespace std;

int globe;
void func();
int main() {
 globe = 12;
 cout << globe << endl;
 func();
 cout << globe << endl;
}

// global2.cpp
extern int globe;
void func() {
 globe =47;
}

Because global2.cpp compiled separately from global.cpp compile must be informed that the var exists by declaration.
                        Local vars
Those vars "local" to a func.They are often called "automatic" cause they automaticly come into being when the scope entered and go away when the scope closes. The keyword auto makes this explicit, but local vars default to auto so it's never necessary to declare. The register keyword tells the compiler "make access to this var as fast as possible".The restrictions is - can't take or compute the address of register var. 
Can't have global or static register var.
                        Static
Often var declared in scope of func disappear at the end of the func scope. So every 
executing of func will create new vars and values are reinitialized. If you want a vlaue to be extant throughout the life of a program needs to define local var w/ keyword static and give
 it an initial value. The initialization is perfomed only the first timethe func is called and the data remains value between func calls. The static var is not accessable out of func scope. When static used w/ func name or var declared outside of any func scope it's mean - That name is unavailable outside of this file.It file scope.
                        Extern
This will tell to compiler that the definition exists somewhere as a global var.If put static before extern will cause to linker error.
                        Linkage
Every identifier is represented by storage in memory that holds a var or a compiled func body. There are two types of linkage: internal and external.
Internal : the storage created is created to represent identifier only for the file being compiled.Other files may use the same identifier name with internal linkage or for a global var and will be no conflicts.Internal linkage is specified by keyword static.
External : the storage created to represent the identifier for all file being compiled. 
The storage created once and linker must resolve all other references to that storage. Global vars and funcs name have external linkage.
        ???
                        Constants
C++ concept of a named constant is just like a var, except that its value cann't be changed. 
The modifier const tells compiler that a name represents a constant.
The constant must always have initialization value.Values w/o type assumes as decimal. Constant w/ leading 0 treated as octal; w/ 0x treated as hex.Possible to add suffixes to force the type of floating-point number: f or F - a float; l or L - long double, otherwise will be double.
Char constnts are chars surrounded by single quotes. Special chars represented w/ backslash.
\n - new line; \t - tab; \\ - backslash; \r - carriage return; \" - double quotes; \' - single quote.
Also char const in octal - '\17' or hex - '\xff'.

                        volatile
Prevent compiler from optimizing certain var or const.

Operators
Assigment
Operator = where right-hand side ( calld rvalue ) copy to left-hand side ( lvalue ).

Math operators
+ addition - substraction / division * multiplication % modulus
% - produces reminder from integer division ( can't use float-point numbers. )

Relational operators
Establish a relationship between the values of the operands and produce a Boolean,
true or false. 
< > <= >= == !=

Logical operators
Operators and ( && ) and or ( || ) produce true or false.Statement true if it has non-zero
value.

Bitwise operators
Manipulate w/ individual bits. Works only w/ integral types char , int , long.
The bitwise and ( & ) produce 1 if both input bits are 1, otherwise 0.
The bitwise or ( | ) produce 0 if both input bits are 0 ,otherwise 1.
The bitwise exclusive or ( ^ ) produce 1 if one of input bits 1 ,but not both.
The bitwise not ( ~ ) produce opposite of the input bit.

Shift operators
The left-shift ( << ) produces the operand to the left of the operator shifted to the left by the
number of bits specified after the operator.
The right-shift ( >> ) produces the operand to the left of the operator shifted to the right by the number of bits specified after the operator.
Example func displays single byte bit-by-bit
void printByte( const unsigned char val)
 for ( i = 7; i >= 0 ; i--) {
   if( val & ( 1 << i ) )
        std::cout << "1";
   else
        std:cout << "0";
  }

Unary operators
Bitwise not ( ~ ), logical not ( ! ), minus( - ), plus ( + ), increment and decrement ( ++ -- ),
address-of ( & ), dereference ( * -> ), cast operator and new and delete in C++.

The ternary operator
The operator if-else and conditional operator ( ? ).

The comma operator
The ( , ) operator used to separate expressions.For example multipile definitions:
int i, j, k;
and increment list of vars and uses the last one as rvalue:
a = (b++,c++,d++,e++);

Casting
Additional cast syntax:
float a = float(200)l;
float b = (float)200;
Explicit C++ cast syntax:
static_cast
        ???
const_cast
        ???
reinterpret_cast
        ???
dynamic_cast
        ???

Composite type creation
First is typedef that is alias to existing type. In case
int* x,y;
would be int* which is x and int which is y.
Enumarations.
In C this simple associating integral values w/ names, but in C++ it's also type checking.
Actualy in C++ creates a new type and name of enumaration becomes reserved word.
In addition in C++ type checking of enum stricker.In C you can do with instance a of 
enumaration color like a++ but in C++ can't , cause it's contents 2 type conversions.
From color to int ( permited in C++ ) and back that is forbidden.
The next is union.Puts all data into a single space; it's figures out the amount of space
necessary for the lagest item of union.
Next is arrays.Method to pack data together but nice dynamical array in C. In C++ there
is vector object that auto-resides itself.
???

Debuging hints
???