C++ Tutorial With Examples
C++ Tutorial With Examples
This text enunciates and illustrates features and basic principles of C++. It is aimed at
experienced C users who wish to learn C++. It can also be interesting for beginner C++
users who leaved out some possibilities of the language. A printed version is available at
http://www.lulu.com/content/258714
14. The symbolic operators (+ - * / ...) can be defined for new data
types
15. Different functions for different data types will automatically be
generated provided you define a template function
16. The keywords new and delete are much better to allocate and
deallocate memory
20. The method bodies can be defined below the class definition (and
Makefile usage example)
27. If a method is declared virtual the program will always first check
the type of an instance that is pointed to and will use the
appropriate method.
28. A class can be derived from more than one base class
int main ()
{
double a;
a = 1.2;
a = sin (a);
return 0;
}
To compile this program, type it inside (or copy & paste it to) a text editor (gedit, kwrite,
kate, kedit, vi, emacs, nano, pico, mcedit, Notepad...), save it as a file named say
test01.cpp (if you are a newbie, best put this file inside your home directory, that is say
/home/jones on a Unix-like box).
To compile this source code file, type this command (on most open-source Unix-like
boxes) in a console or terminal window:
To run the binary executable file test01 that has been produced by the compilation (if
there were no errors), type this:
./test01
Each time you modify the test01.cpp source code file, you need to compile it again if
you want the modifications to echo in the test01 executable file (type the upward arrow
key on your keyboard to recall commands).
2.
You can use // to type a remark:
a = 456.47;
a = a + a * 21.5 / 100; // A calculation.
(The possibility to use // to type remarks has been added to C in C99 and ANSI C 2000.)
3.
Input from keyboard and output to screen can be performed through cout << and cin >>:
void main()
{
int a; // a is an integer variable
char s [100]; // s points to a string of max 99
characters
cout << "Hello " << s << " you're " << a << " old." << endl;
cout << endl << endl << "Bye!" << endl;
return 0;
}
4.
Variables can be declared everywhere inside the code without using hooks:
int main ()
{
double a;
a = (a + 1) / 2;
double c;
c = a * 5 + 1;
int i, j;
i = 0;
j = i + 1;
Maybe try to use this feature to make your source codes more readable and not to mess
them up.
Like in C, variables can be encapsulated between { } hooks. Then they are local to the
zone encapsulated between the { and }. Whatever happens with such variables inside the
encapsulated zone will have no effect outside the zone:
int main ()
{
double a;
{
int a = 1;
a = a * 10 + 4;
cout << "Local number: " << a << endl;
}
return 0;
}
5.
A variable can be initialised by a calculation involving other variables:
int main ()
{
double a = 12 * 3.25;
double b = a + 1.112;
cout << "a contains: " << a << endl;
cout << "b contains: " << b << endl;
a = a * 2 + b;
double c = a + b * a;
return 0;
}
6.
C++ allows to declare a variable to be local to a loop:
int main ()
{
int i; // Simple declaration of i
i = 487;
return 0;
}
In case the variable is not declared somewhere above the loop, you may be tempted to
use it below the loop. Some early C++ compilers accept this. Then the variable has the
value it had when the loop ended. You shouldn't do this. It's a bad practice:
int main ()
{
for (int i = 0; i < 4; i++)
{
cout << i << endl;
}
return 0;
}
7.
A global variable can be accessed even if another variable with the same name has been
declared inside the function:
double a = 128;
int main ()
{
double a = 256;
return 0;
}
8.
It is possible to make one variable be another:
using namespace std;
#include <iostream>
int main ()
{
double a = 3.1415927;
double &b = a; // b is a
b = 89;
cout << "a contains: " << a << endl; // Displays 89.
return 0;
}
(If you are used at pointers and absolutely want to know what happens, simply think
double &b = a is translated to double *b = &a and all subsequent b are replaced by *b.)
The value of REFERENCE b cannot be changed after its declaration. For example you
cannot write, a few lines further, &b = c expecting now b is c. It won't work. Everything
is said on the declaration line of b. Reference b and variable a are married on that line
and nothing will separate them.
int main ()
{
double k, m;
k = 3;
m = 4;
cout << k << ", " << m << endl; // Displays 100, 4.
return 0;
}
If you are used at pointers in C and wonder how exactly the program above works, here is
how the C++ compiler would translate it to C:
int main ()
{
double k, m;
k = 3;
m = 4;
cout << k << ", " << m << endl; // Displays 100, 4.
return 0;
}
int main ()
{
double k = 3;
double m = 7;
return 0;
}
Again, provided you're used at pointer arithmetics and if you wonder how the program
above works, just think the compiler translated it into the following standard C program:
int main ()
{
double k = 3;
double m = 7;
return 0;
}
To end with, for people who have to deal with pointers yet do not like it, references are
useful to un-pointer variables. Beware this is considered a bad practice. You can go into
trouble. See for example http://www.embedded.com/story/OEG20010311S0024.
int main ()
{
double *a;
a = silly_function();
b += 1; // Great!
b = b * b; // No need to write *a everywhere!
b += 4;
return 0;
}
9.
Namespaces can be declared. The variables declared within a namespace can be used
thanks to the :: operator:
namespace first
{
int a;
int b;
}
namespace second
{
double a;
double b;
}
int main ()
{
first::a = 2;
first::b = 5;
second::a = 6.453;
second::b = 4.1e4;
return 0;
}
10.
If they contain just simple lines of code, use no for loops or the like, C++ functions can
be declared inline. This means their code will be inserted right everywhere the function is
used. That's somehow like a macro. Main advantage is the program will be faster. A little
drawback is it will be bigger, because the full code of the function was inserted
everywhere it is used:
int main ()
{
double k = 6, m = 9;
(The possibility to use inline functions has been added to C in C99 and ANSI C 2000.)
11.
You know the classical structures of C: for, if, do, while, switch... C++ adds one more
structure named EXCEPTION:
int main ()
{
int a, b;
try
{
if (a > 100) throw 100;
if (a < 10) throw 10;
throw a / 3;
}
catch (int result)
{
cout << "Result is: " << result << endl;
b = result + 1;
}
try
{
if (a == 0) throw zero;
if ((a / 2) * 2 == a) throw pair;
for (int i = 3; i <= sqrt (a); i++)
{
if ((a / i) * i == a) throw notprime;
}
throw prime;
}
catch (char *conclusion)
{
cout << "The number you typed is "<< conclusion << endl;
}
return 0;
}
12.
It is possible to define default parameters for functions:
int main ()
{
cout << test (14, 5) << endl; // Displays 14 - 5
cout << test (14) << endl; // Displays 14 - 7
return 0;
}
13.
One important advantage of C++ is the OPERATOR OVERLOAD. Different functions
can have the same name provided something allows to distinguish between them: number
of parameters, type of parameters...
int main ()
{
double m = 7, n = 4;
int k = 5, p = 3;
cout << test(m, n) << " , " << test(k, p) << endl;
return 0;
}
14.
The OPERATORS OVERLOAD can be used to define the basic symbolic operators for
new sorts of parameters:
struct vector
{
double x;
double y;
};
vector operator * (double a, vector b)
{
vector r;
r.x = a * b.x;
r.y = a * b.y;
return r;
}
int main ()
{
vector k, m; // No need to type "struct vector"
m = 3.1415927 * k; // Magic!
cout << "(" << m.x << ", " << m.y << ")" << endl;
return 0;
}
Besides multiplication, 43 other basic C++ operators can be overloaded, including +=, +
+, the array [], and so on...
The operation cout << is an overload of the binary shift of integers. That way the <<
operator is used a completely different way. It is possible to overload the << operator for
the output of vectors:
struct vector
{
double x;
double y;
};
int main ()
{
vector a;
a.x = 35;
a.y = 23;
return 0;
}
15.
Tired of defining five times the same function? One definition for int type parameters,
one definition for double type parameters, one definition for float type parameters...
Didn't you forget one type? What if a new data type is used? No problem: the C++
compiler can generate automatically every version of the function that is necessary! Just
tell him how the function looks like by declaring a template function:
r = a;
if (b < a) r = b;
return r;
}
int main ()
{
int i1, i2, i3;
i1 = 34;
i2 = 6;
i3 = minimum (i1, i2);
cout << "Most little: " << i3 << endl;
cout << "Most little: " << minimum (d3, 3.5) << endl;
return 0;
}
The function minimum is used three times in above program yet the C++ compiler
generates only two versions of it: int minimum (int a, int b) and double minimum
(double a, double b). That does the job for the whole program.
Would you have tried something like calculating minimum (i1, d1) the compiler would
have reported that as an error. Indeed the template tells both parameters are of the same
type.
You can use a random number of different template data types in a template definition.
And not all parameter types must be templates, some of them can be of standard types or
user defined (char, int, double...). Here is an example where the minimum function
takes parameters of any, possibly different, types and outputs a value that has the type of
the first parameter:
int main ()
{
int i;
double d;
i = 45;
d = 7.41;
cout << "Most little: " << minimum (i, d) << endl;
cout << "Most little: " << minimum (d, i) << endl;
cout << "Most little: " << minimum ('A', i) << endl;
return 0;
}
16.
The keywords new and delete can be used to allocate and deallocate memory. They are
much sweeter than the functions malloc and free from standard C.
int main ()
{
double *d; // d is a variable whose purpose
// is to contain the address of a
// zone where a double is located
*d = *d + 5;
d[0] = 4456;
d[1] = d[0] + 567;
cout << "Content of d[1]: " << d[1] << endl;
int n = 30;
delete [] d;
char *s;
s = new char[100];
delete [] s;
return 0;
}
17.
In standard C a struct just contains data. In C++ a struct definition can also include
functions. Those functions are own to the struct and are meant to operate on the data of
the struct. Those functions are called METHODS. Example below defines the method
surface() on the struct vector:
using namespace std;
#include <iostream>
struct vector
{
double x;
double y;
double surface ()
{
double s;
s = x * y;
if (s < 0) s = -s;
return s;
}
};
int main ()
{
vector a;
a.x = 3;
a.y = 4;
return 0;
}
In the example above, a is an INSTANCE of struct "vector". (Note that the keyword
"struct" was not necessary when declaring vector a.)
Just like a function, a method can be an overload of any C++ operator, have any number
of parameters (yet one parameter is always implicit: the instance it acts upon), return any
type of parameter, or return no parameter at all.
What is a class? It's a struct yet that tends to keep its data hidden. Only the methods of
the class can access the data. You can't access the data directly, unless authorized by the
public: directive. Here is an example of a class definition. It behaves exactly the same
way as the struct example above because the class data x and y are kept public:
class vector
{
public:
double x;
double y;
double surface ()
{
double s;
s = x * y;
if (s < 0) s = -s;
return s;
}
};
int main ()
{
vector a;
a.x = 3;
a.y = 4;
return 0;
}
In the example above, the main() function changes the data of instance a directly, using
a.x = 3 and a.y = 4. This is made possible by the public: directive in the class definition.
This is a bad practice. See chapter 30.
class vector
{
public:
double x;
double y;
vector its_oposite()
{
vector r;
r.x = -x;
r.y = -y;
return r;
}
void be_oposited()
{
x = -x;
y = -y;
}
r.x = x * a;
r.y = y * a;
return r;
}
};
int main ()
{
vector a, b;
a.x = 3;
b.y = 5;
b = a.its_oposite();
cout << "Vector a: " << a.x << ", " << a.y << endl;
cout << "Vector b: " << b.x << ", " << b.y << endl;
b.be_oposited();
cout << "Vector b: " << b.x << ", " << b.y << endl;
a = b * 2;
cout << "Vector a: " << a.x << ", " << a.y << endl;
a = b.its_oposite() * 2;
cout << "Vector a: " << a.x << ", " << a.y << endl;
return 0;
}
18.
Very special and essential methods are the CONSTRUCTOR and DESTRUCTOR. They
are automatically called whenever an instance of a class is created or destroyed (variable
declaration, end of program, new, delete...).
The constructor will initialize the variables of the instance, do some calculation, allocate
some memory for the instance, output some text... whatever is needed.
class vector
{
public:
double x;
double y;
};
int main ()
{
vector k; // vector () is called
cout << "vector k: " << k.x << ", " << k.y << endl << endl;
cout << "vector m: " << m.x << ", " << m.y << endl << endl;
cout << "vector k: " << k.x << ", " << k.y << endl << endl;
return 0;
}
It is a good practice to try not to overload the constructors. Best is to declare only one
constructor and give it default parameters wherever possible:
class vector
{
public:
double x;
double y;
int main ()
{
vector k;
cout << "vector k: " << k.x << ", " << k.y << endl << endl;
vector p (3);
cout << "vector p: " << p.x << ", " << p.y << endl << endl;
return 0;
}
The destructor is often not necessary. You can use it to do some calculation whenever an
instance is destroyed or output some text for debugging... But if variables of the instance
point towards some allocated memory then the role of the destructor is essential: it must
free that memory! Here is an example of such an application:
class person
{
public:
char *name;
int age;
cout << "Instance going to be deleted, 100 bytes freed" << endl;
}
};
int main ()
{
cout << "Hello!" << endl << endl;
person a;
cout << a.name << ", age " << a.age << endl << endl;
person b ("John");
cout << b.name << ", age " << b.age << endl << endl;
b.age = 21;
cout << b.name << ", age " << b.age << endl << endl;
return 0;
}
Here is a short example of an array class definition. A method that is an overload of the []
operator and that outputs a reference (&) is used in order to generate an error if it is tried
to access outside the limits of an array:
using namespace std;
#include <iostream>
#include <cstdlib>
class array
{
public:
int size;
double *data;
array (int s)
{
size = s;
data = new double [s];
}
~array ()
{
delete [] data;
}
int main ()
{
array t (5);
t[0] = 45; // OK
t[4] = t[0] + 6; // OK
cout << t[4] << endl; // OK
t[10] = 7; // error!
return 0;
}
19.
If you cast an object like a vector, everything will happen all right. For example if vector
k contains (4, 7), after the cast m = k the vector m will contain (4, 7) too. The values of
k.x and k.y have simply been copied to m.x and m.y. Now suppose you're playing with
objects like the person class above. Those objects contain a pointer to a character string.
If you cast such person object by writing p = r it is necesary that some function does the
work to make p be a correct copy of r. Indeed otherwise p.name will point to the
physical same character string as r.name. What's more the former character string
pointed towards by p.name is lost and becomes a memory zombie. The result will be
catastrophic: a mess of pointers and lost data. The methods that will do the job are the
COPY CONSTRUCTOR and an overload of the = operator:
class person
{
public:
char *name;
int age;
~person ()
{
delete [] name;
}
};
int main ()
{
person p;
cout << p.name << ", age " << p.age << endl << endl;
person k ("John", 56);
cout << k.name << ", age " << k.age << endl << endl;
p = k;
cout << p.name << ", age " << p.age << endl << endl;
return 0;
}
The copy constructor allows your program to make copies of instances when doing
calculations. It is a key method. During calculations, instances are created to hold
intermediate results. They are modified, casted and destroyed without you being aware.
This is why those methods can be useful even for simple objects (see chapter 14.).
In all the examples above the methods are defined inside the class definition. That makes
them automatically be inline methods.
20.
If a method cannot be inline, if you do not want it to be inline, if you want the class
definition contain the minimum of information (or simply if you want the usual separated
.h header file and .cpp source code file), then you must just put the prototype of the
method inside the class and define the method below the class (or in a separated .cpp
source file):
class vector
{
public:
double x;
double y;
return s;
}
int main ()
{
vector k;
k.x = 4;
k.y = 5;
return 0;
}
For beginners :
If you intent to develop a serious C or C++ software, you need to separate the source
code in .h header files and .cpp source files. This is a short example of how it is done.
The program above is split in three files :
class vector
{
public:
double x;
double y;
double surface();
};
return s;
}
int main ()
{
vector k;
k.x = 4;
k.y = 5;
return 0;
}
Assuming vector.cpp is perfect, you compile it once and for all into a .o "object file".
The command below produces that object code file, that will bear the name vector.o:
g++ -c vector.cpp
Each time you modify the main.cpp source code file you compile it into say a test20
executable file. You tell the compiler explicitely it has to link the vector.o object file into
the final test20 executable:
./test20
• You can give somebody the .h file and the .o file(s). That way he can use your
software but not change it because he doesn't have the .cpp file(s) (don't rely too
much on this, wait till you master these questions).
Note you can compile main.cpp too into an object file and then link it with vector.o:
g++ -c main.cpp
If you want to look like a real C or C++ programmer you need to condense all this in a
Makefile and compile using the make command. The file content beneath is an
oversimplified version of such a Makefile. Copy it in a file named Makefile. Please note,
and this is very important, that you need to replace the spaces before the g++ commands
by a Tab character.
make test20
The make command will parse through the file Makefile and infere what it has to do. To
start with it will understand that test20 depends on main.o and vector.o. So it will
automatically launch "make main.o" and "make vector.o". Then it will check if
test20 allready exists and check for the date stamps of test20, main.o and vector.o. If
test20 allready exists and main.o and vector.o have a date stamp earlier than test20,
the make command understands current version of test20 is up to date so it has nothing
to do. It will just report it did nothing. Otherwise, if test20 does not exist, or main.o or
vector.o are more recent than test20, the command that creates an up to date version of
test20 is executed, that is g++ main.o vector.o -o test20.
all: test20
clean:
rm -f *.o test20 *~ #*
You trigger the compilation by just typing the make command. The first line in the
Makefile implies that if you just type make you intent "make test20":
make
This command erases all the files produced during compilation and all text editors
backup files:
make clean
21.
When a method is applied to an instance, that method may use the instance's variables,
modify them... But sometimes it is necessary to know the address of the instance. No
problem, the keyword this is intended therefore:
using namespace std;
#include <iostream>
#include <cmath>
class vector
{
public:
double x;
double y;
double module()
{
return sqrt (x * x + y * y);
}
length = this->module();
x = x / length * a;
y = y / length * a;
}
};
int main ()
{
vector c (3, 5);
cout << "The module of vector c: " << c.module() << endl;
cout << "The module of vector c: " << c.module() << endl;
cout << "The module of vector c: " << c.module() << endl;
return 0;
}
22.
Of course it is possible to declare arrays of objects:
class vector
{
public:
double x;
double y;
double module ()
{
return sqrt (x * x + y * y);
}
};
int main ()
{
vector s [1000];
s[23] = t[2];
return 0;
}
23.
Here is an example of a full class declaration:
using namespace std;
#include <iostream>
#include <cmath>
class vector
{
public:
double x;
double y;
vector vector::operator - ()
{
return vector (-x, -y);
}
double vector::module()
{
return sqrt (x * x + y * y);
}
x = x / length * a;
y = y / length * a;
}
int main ()
{
vector a;
vector b;
vector c (3, 5);
a = c * 3;
a = b + c;
c = b - c + a + (b - a) * 7;
c = -c;
cout << "The module of vector c: " << c.module() << endl;
double k;
k = vector(1, 1).module(); // k will contain 1.4142.
cout << "k contains: " << k << endl;
return 0;
}
It is also possible to define the sum of vectors without mentioning it inside the vector
class definition. Then it will not be a method of the class vector. Just a function that uses
vectors:
Of course the keywords new and delete work for class instances too. What's more, new
automatically calls the constructor in order to initialize the objects, and delete
automatically calls the destructor before deallocating the zone of memory the instance
variables take:
class vector
{
public:
double x;
double y;
double vector::module()
{
return sqrt (x * x + y * y);
}
x = x / length * a;
y = y / length * a;
}
int main ()
{
vector c (3, 5);
r->x = 94;
r->y = 345;
cout << *r << endl;
*r = *r - c;
r->set_length(3);
cout << *r << endl;
*r = (-c * 3 + -*r * 4) * 5;
cout << *r << endl;
delete r;
int n = 5;
r = new vector[n]; // Cute!
delete [] r;
return 0;
}
24.
A class' variable can be declared static. Then only one instance of that variable exists,
shared by all instances of the class. It must be initialised outside the class declaration :
class vector
{
public:
double x;
double y;
static int count;
~vector()
{
count--;
}
};
int vector::count = 0;
int main ()
{
cout << "Number of vectors:" << endl;
vector a;
cout << vector::count << endl;
vector b;
cout << vector::count << endl;
r = new vector;
cout << vector::count << endl;
u = new vector;
cout << a.count << endl;
delete r;
cout << vector::count << endl;
delete u;
cout << b.count << endl;
return 0;
}
25.
A class variable can also be constant. That's just like static, except it is alocated a value
inside the class declaration and that value may not be modified:
class vector
{
public:
double x;
double y;
const static double pi = 3.1415927;
double cilinder_volume ()
{
return x * x / 4 * pi * y;
}
};
int main()
{
cout << "The value of pi: " << vector::pi << endl << endl;
return 0;
}
26.
A class can be DERIVED from another class. The new class INHERITS the variables
and methods of the BASE CLASS. Additional variables and/or methods can be added:
class vector
{
public:
double x;
double y;
double module()
{
return sqrt (x*x + y*y);
}
double surface()
{
return x * y;
}
};
double volume ()
{
return this->surface() * z; // or x * y * z
}
};
int main ()
{
vector a (4, 5);
trivector b (1, 2, 3);
cout << "a (4, 5) b (1, 2, 3) *r = b" << endl << endl;
trivector k;
k = a; // thanks to trivector(vector) definition
// copy of x and y, k.z = 0
vector j;
j = b; // copy of x and y. b.z leaved out
vector *r;
r = &b;
return 0;
}
27.
In the program above, r->module() calculates the vector module, using x and y, because
r has been declared a vector pointer. The fact r actually points towards a trivector is not
taken into account. If you want the program to check the type of the pointed object and
choose the appropriate method, then you must declare that method virtual inside the base
class.
(If at least one of the methods of the base class is virtual then a "header" of 4 bytes is
added to every instance of the classes. This allows the program to determine towards
what a vector actually points.)
class vector
{
public:
double x;
double y;
double module ()
{
return sqrt (x*x + y*y + z*z);
}
};
int main ()
{
vector a (4, 5);
trivector b (1, 2, 3);
cout << "a (4, 5) b (1, 2, 3)" << endl << endl;
vector *r;
r = &a;
cout << "module of vector a: " << r->module() << endl;
r = &b;
cout << "module of trivector b: " << r->module() << endl;
test (a);
test (b);
vector &s = b;
return 0;
}
28.
Maybe you wonder if a class can be derived from more than one base class. Answer is
yes:
class vector
{
public:
double x;
double y;
double surface()
{
return fabs (x * y);
}
};
class number
{
public:
double z;
number (double a)
{
z = a;
}
int is_negative ()
{
if (z < 0) return 1;
else return 0;
}
};
double volume()
{
return fabs (x * y * z);
}
};
int main ()
{
trivector a(2, 3, -4);
return 0;
}
29.
Class derivation allows to construct "more complicated" classes build above base classes.
There is another application of class derivation: allow the programmer to write generic
functions.
Suppose you define a base class with no variables. It makes no sense to use instances of
that class inside your program. But you write a function whose purpose is to sort
instances of that class. That function will be able to sort any types of objects provided
they belong to a class derived from that base class! The only condition is that inside every
derived class definition, all methods the sort function needs are correctly defined:
using namespace std;
#include <iostream>
#include <cmath>
class octopus
{
public:
double x;
double y;
double module()
{
return sqrt (x * x + y * y);
}
};
double n;
number (double a = 0)
{
n = a;
}
double module()
{
if (n >= 0) return n;
else return -n;
}
};
int main ()
{
vector k (1,2), m (6,7), n (100, 0);
number p (5), q (-3), r (-150);
return 0;
}
Perhaps you think "okay, that's a good idea to derive classes from the class octopus
because that way I can apply to instances of my classes methods and function that were
designed a generic way for the octopus class. But what if there exists another base class,
named cuttlefish, which has very interesting methods and functions too? Do I have to
make my choice between octopus and cuttlefish when I want to derive a class?" No, of
course. A derived class can be at the same time derived from octopus and from
cuttlefish. That's POLYMORPHISM. The derived class simply has to define the methods
necessary for octopus together with the methods necessary for cuttlefish:
class octopus
{
virtual double module() = 0;
};
class cuttlefish
{
virtual int test() = 0;
};
double module ()
{
return sqrt (x * x + y * y);
}
int test ()
{
if (x > y) return 1;
else return 0;
}
}
30.
The public: directive means the variables or the methods below can be accessed and
used everywhere in the program.
If you want the variables and methods to be accessible only to methods of the class AND
to methods of derived classes then you must put the keyword protected: above them.
If you want variables or methods be accessible ONLY to methods of the class then you
must put the keyword private: above them.
The fact variables or methods are declared private or protected means nothing external to
the class may access or use them. That's ENCAPSULATION. (If you want to give to a
specific function the right to access those variables and methods then you must include
that function's prototype inside the class definition, preceded by the keyword friend.)
The good practice is to encapsulate all the variables of a class. This can sound strange if
you're common to structs in C. Indeed a struct only makes sense if you can access its
data... In C++ you have to create methods to acces the data inside a class. Example below
uses the basic example of chapter 17 yet declares the class data to be protected:
class vector
{
protected:
double x;
double y;
public:
int main ()
{
vector a;
a.set_x (3);
a.set_y (4);
return 0;
}
The example above is a bit odd since the class data x and y can be set yet they cannot be
read back. Any attempt in function main () to read a.x or a.y will result in a compilation
error. In next example x and y can be read back:
class vector
{
protected:
double x;
double y;
public:
double get_x ()
{
return x;
}
double get_y ()
{
return y;
}
double surface ()
{
double s;
s = x * y;
if (s < 0) s = -s;
return s;
}
};
int main ()
{
vector a;
a.set_x (3);
a.set_y (4);
return 0;
}
In C++ one is not supposed to access the data of a class directly. Methods have to be
declared. Why this? Many reasons exist. One is this allows tho change the way the data is
memorized inside the class. Another reason is this allows data inside the class to be cross-
dependent. Suppose x and y must always be of the same sign, otherwize ugly things can
happen... If one is allowed to access the class data directly, it would be easy to impose
say a positive x and a negative y. In example below this is severely controlled:
class vector
{
protected:
double x;
double y;
public:
double get_x ()
{
return x;
}
double get_y ()
{
return y;
}
double surface ()
{
double s;
s = x * y;
if (s < 0) s = -s;
return s;
}
};
int main ()
{
vector a;
a.set_x (-3);
a.set_y (4);
return 0;
}
31.
Let's talk about input/output. In C++ that's a very broad subject.
int main ()
{
fstream f;
f.open("c:\\test.txt", ios::out);
double a = 345;
f.close();
return 0;
}
int main ()
{
fstream f;
char c;
f.open("c:\\test.txt", ios::in);
while (! f.eof() )
{
f.get(c); // Or c = f.get()
cout << c;
}
f.close();
return 0;
}
32.
Roughly said, it is possible to do on character arrays the same operations as on files. This
is very useful to convert data or manage memory arrays.
int main ()
{
char a[1024];
ostrstream b(a, 1024);
double v = 2;
b.seekp(strlen (a));
b << "sin (" << v << ") = " << sin(v) << ends;
return 0;
}
int main ()
{
char a[1024];
istrstream b(a, 1024);
double k, p;
b.seekg(0); // Start from first character.
b >> k;
k = k + 1;
b.seekg(0);
b >> k >> p;
return 0;
}
33.
This program performs formated output two different ways. Please note the width() and
setw() MODIFIERS are only effective on the next item output to the stream. The second
next item will not be influenced.
int main ()
{
int i;
return 0;
}
You now have a basic knowledge about C++. Inside good books you will learn many
more things. The file management system is very powerful, it has many other
possibilities than those illustrated here. There is also a lot more to say about classes:
template classes, virtual classes...
In order to work correctly with C++ you will need a good reference book, just like you
need one for C. You will also need information on how C++ is used in your particular
domain of activity. The standards, the global approach, the tricks, the typical problems
encountered and their solutions... The best reference is of course the books written by
Bjarn Stroustrup himself (I don't remind which one of them I read). Following book
contains almost every detail about C and C++ and is constructed a way similar to this
text:
French edition:
C/C++ La Bible du programmeur
Kris Jamsa, Ph.D - Lars Klander
France : Editions Eyrolles
www.eyrolles.com
Canada : Les Editions Reynald Goulet inc.
www.goulet.ca
ISBN 2-212-09058-7
Other reference:
accu
CoderSource.net
I wish to thank Didier Bizzarri, Toni Ronkko, Frédéric Cloth, Jack Lam, Morten Brix
Pedersen, Elmer Fittery, Ana Yuseepi, William L. Dye, Bahjat F. Qaqish, Muthukumar
Veluswamy, Marco Cimarosti, Jarrod Miller, Nikolaos Pothitos and Ralph Wu for their
inspiration, advice, help, data, bug reports and references.
Eric Brasseur - February 23 1998 till March 12 2006 [ Homepage |
]