Advance features of C++

The Global Open University
Nagaland
C++
Special guide of tricks in

 Pointers
 Arrays and strings
 Parameter passing
 Class basics
 Constructors & destructors
 Class Hierarchy
 Virtual Functions
 Coding tips
 Advanced topics

int *intPtr;
intPtr = new int;
*intPtr = 6837;
delete intPtr;
int otherVal = 5;
intPtr = &otherVal;
Create a pointer
Allocate memory
Set value at given address
Change intPtr to point to
a new location
6837*intPtr
0x0050intPtr
5*intPtr
0x0054intPtr
otherVal
&otherVal
Deallocate memory

int intArray[10];
intArray[0] = 6837;
int *intArray;
intArray = new int[10];
intArray[0] = 6837;
...
delete[] intArray;
Stack allocation
Heap allocation

char myString[20];
strcpy(myString, "Hello World");
myString[0] = 'H';
myString[1] = 'i';
myString[2] = '0';
printf("%s", myString);
A string in C++ is an array of characters
Strings are terminated with the NULL or '0' character
output: Hi

int add(int a, int b) {
return a+b;
}
int a, b, sum;
sum = add(a, b);
pass by value
int add(int *a, int *b) {
return *a + *b;
}
int a, b, sum;
sum = add(&a, &b);
pass by reference
Make a local copy
of a and b
Pass pointers that reference
a and b. Changes made to
a or b will be reflected
outside the add routine

int add(int &a, int &b) {
return a+b;
}
int a, b, sum;
sum = add(a, b);
pass by reference – alternate notation

#ifndef _IMAGE_H_
#define _IMAGE_H_
#include <assert.h>
#include "vectors.h“
class Image {
public:
...
private:
...
};
#endif
Include a library file
Include a local file
Prevents multiple references
Variables and functions
accessible from anywhere
Variables and functions accessible
only from within this class’s functions

Image myImage;
myImage.SetAllPixels(ClearColor);
Image *imagePtr;
imagePtr = new Image();
imagePtr->SetAllPixels(ClearColor);
...
delete imagePtr;
Stack allocation
Heap allocation

image.h Header file: Class definition & function prototypes
.C file: Full function definitions
Main code: Function references
image.C
main.C
void SetAllPixels(const Vec3f &color);
void Image::SetAllPixels(const Vec3f &color) {
for (int i = 0; i < width*height; i++)
data[i] = color;
}
myImage.SetAllPixels(clearColor);

class Image {
public:
Image(void) {
width = height = 0;
data = NULL;
}
~Image(void) {
if (data != NULL)
delete[] data;
}
int width;
int height;
Vec3f *data;
};
Constructor:
Called whenever a
new
instance is created
Destructor:
Called whenever
an
instance is deleted

Image(int w, int h) {
width = w;
height = h;
data = new Vec3f[w*h];
}
Constructors can also take parameters
Image myImage = Image(10, 10);
Image *imagePtr;
imagePtr = new Image(10, 10);
Using this constructor with stack or heap allocation:
stack allocation
heap allocation

Image(Image *img) {
width = img->width;
height = img->height;
data = new Vec3f[width*height];
for (int i=0; i<width*height; i++)
data[i] = img->data[i];
}
Image(Image *img) {
width = img->width;
height = img->height;
data = img->data;
}
A default copy constructor is created automatically,
but it is often not what you want:

bool IsImageGreen(Image img);
If a class instance is passed by value, the copy constructor will
be used to make a copy.
Computationally expensive
bool IsImageGreen(Image *img);
It’s much faster to pass by reference:
bool IsImageGreen(Image &img);
or

class Object3D {
Vec3f color;
};
class Sphere : public Object3D {
float radius;
};
class Cone : public Object3D {
float base;
float height;
};
Child classes inherit parent attributes
Object3D
Sphere Cone

Sphere::Sphere() : Object3D() {
radius = 1.0;
}
Child classes can call parent functions
Child classes can override parent functions
class Object3D {
virtual void setDefaults(void) {
color = RED; }
};
void setDefaults(void) {
color = BLUE;
radius = 1.0 }
};
Call the parent constructor
SuperclassSubclass

class Object3D {
virtual void intersect(Ray *r, Hit *h);
};
virtual void intersect(Ray *r, Hit *h);
};
myObject->intersect(ray, hit);
If a superclass has virtual functions, the correct subclass
version will automatically be selected
Sphere *mySphere = new Sphere();
Object3D *myObject = mySphere;
A superclass pointer can reference a subclass object
Actually calls
Sphere::intersect
SuperclassSubclass

class Object3D {
virtual void intersect(Ray *r, Hit *h) = 0;
};
A pure virtual function has a prototype, but no definition.
Used when a default implementation does not make sense.
A class with a pure virtual function is called a pure
virtual class and cannot be instantiated. (However, its
subclasses can).

int main(int argc, char** argv);
This is where your code begins execution
Number of
arguments
Array of
strings
argv[0] is the program name
argv[1] through argv[argc-1] are command-line input

#define PI 3.14159265
#define MAX_ARRAY_SIZE 20
Use the #define compiler directive for constants
printf("value: %d, %fn", myInt, myFloat);
cout << "value:" << myInt << ", " << myFloat << endl;
Use the printf or cout functions for output and debugging
assert(denominator != 0);
quotient = numerator/denominator;
Use the assert function to test “always true” conditions

delete myObject;
myObject = NULL;
After you delete an object, also set its value to NULL
(This is not done for you automatically)
This will make it easier to debug memory allocation errors
assert(myObject != NULL);
myObject->setColor(RED);

int intArray[10];
intArray[10] = 6837;
Image *img;
img->SetAllPixels(ClearColor);
Typical causes:
Access outside of
array bounds
Attempt to access
a NULL or previously
deleted pointer
These errors are often very difficult to catch and
can cause erratic, unpredictable behavior.

void setToRed(Vec3f v) {
v = RED;
}
Since v is passed by value, it will not get updated outside of
The set function
The fix:
void setToRed(Vec3f &v) {
v = RED;
}
void setToRed(Vec3f *v) {
*v = RED;
}
or

Sphere* getRedSphere() {
Sphere s = Sphere(1.0);
s.setColor(RED);
return &s;
}
C++ automatically deallocates stack memory when the
function exits, so the returned pointer is invalid.
The fix:
Sphere* getRedSphere() {
Sphere *s = new Sphere(1.0);
s->setColor(RED);
return s;
}
It will then be your
responsibility to
delete the Sphere
object later.

Lots of advanced topics, but few will be required for this course
• friend or protected class members
• inline functions
• const or static functions and variables
• compiler directives
• operator overloading
Vec3f& operator+(Vec3f &a, Vec3f &b);

This material has been taken from Online
Certificate course on C++ from Global Open
University Online certification programme. For
complete course material visit:
http://tgouwp.eduhttp://tgouwp.edu
About Global Open University :
The global open university is now offering certification courses in
various fields. Even you can study, give exam from comfort of
your home. These are short term and totally online courses. For
more details you can visit:
Email id: info@tgouwp.edu

Advance features of C++

More Related Content

What's hot (18)

Viewers also liked (6)

Similar to Advance features of C++ (20)

Recently uploaded (20)

Advance features of C++

Editor's Notes