C Programming

Object oriented programming, on the other hand, shifts your primary focus to the data itself. Instead of asking "what do I want to do and what will I need to know to do it", you ask "what kind of things do I want to have and what can those things do for me". Instead of designing your functions first and then coming up with data structures to support them, you design types first and then come up with the operations needed to work with them.

For example, consider a simple drawing program where you have a set of shapes (circles, rectangles, etc.) that share certain things in common (they all have a location, size, and color) but are different in other ways (how they look or whether they can be rotated). In a structured program, you'd write a function to draw a shape, containing logic like "if the shape is a circle, do ABC; if it's a rectangle, do XYZ" and so on.

But in an OO program, you'd simply tell the shape to draw itself, and the shape would know, based on its own type, what to do: you write a specialized drawing function when you define each shape, and when you send a "draw" message to any shape, it automatically calls the one for the correct shape type. Polymorphism eliminates the need for you to check what kind of shape it is: you just have to know that shapes can draw themselves, and let the shape worry about how it actually happens.

Another important OO principle is encapsulation, the ability to bundle code and data together in one place and hide that data from the outside world, forcing anyone who wants to access it to go through the associated code. For example, all shapes have a location and a size, but the best representation might be different. A circle only needs three numbers (center X, center Y, and radius) but a rectangle needs four (top, bottom, left, right). Structured programming encourages code everywhere to deal directly with the innards of data structures, so most likely you'd need to use the same representation for all shapes in order to avoid checking the type every time you wanted to measure a shape, even though that representation is wasteful for circles.

Object oriented programming addresses that problem two ways: first, encapsulation says that the internal representation of a shape is off-limits to anyone else, so if you want to know how big a shape is, you have to call its getSize() method instead of reading its size directly out of memory. Second, polymorphism allows different shapes to implement their getSize() methods differently, allowing circles to use a more efficient version while presenting the same interface to the outside world.

Finally, there's inheritance, which makes it easy to extend existing structures to produce new structures with slightly different behavior. For example, a filled circle is mostly the same as a regular circle, but it draws itself differently and also has a fill color. In a structured program, you'd probably handle filled circles by adding a fill color to all shapes and a flag that indicates whether the shape is filled or not, and the fill color would simply go unused (wasting memory) in unfilled shapes. In an object-oriented program, you can make FilledCircle a subclass of Circle, inheriting all the existing circle behavior, and then replace the draw() method and add a place to store the fill color. Then if you changed something about Circle later, the change would automatically propagate to FilledCircle, while changes you made to FilledCircle would not affect any other shapes.

Differences: Typically object oriented is viewed as more difficult. This is because an entirely different problem solving approach must be taking. In addition, there are a variety of object-oriented-only concepts such as classes and inheritance. For simple programs, procedural is often preferred. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

Other notes: Not all languages fall strictly into procedural or object oriented baskets. In actuality, it is more of a spectrum. Languages like Basic and C are pretty much entirely procedural. Languages like C++ and Pascal can be written in either procedural or object oriented styles. Languages like Java and Python adhere much more strictly to object oriented design (although some programmers argue these aren't TRUE object oriented languages).

DDA Line Drawing Algorithm

Step 1:[Determine The Dx & Dy]

Dx=Xb-Xa

Dy=Yb-Ya

Step 2:[Determine Slope is Gentle or Sharp]

If |Dx|>|Dy| then

Gentle Slope

M=Dy/Dx

Set The Starting Point

If Dx>0 Then

C=CELING(Xb)

D=Yb+M*(C-Xb)

F=FLOOR(Xa)

R=FLOOR(D+0.5)

H=R-D+M

IF M>0 Then

Positive Gentle Slope

M1=M-1

Now Step Through The Columns

WHILE C<=F

The simple answer is that the program has undefined behaviour and is therefore an invalid program. There's no easy way to know what will happen because you have (knowingly or otherwise) violated a fundamental language rule; the unconditional access of memory outwith the range of the array. That memory may or may not belong to your program, but there is no way to tell for sure, thus the behaviour is undefined. Perhaps nothing bad will happen at all, or the program will simply crash. But with undefined behaviour, absolutely anything can happen and there's simply no way of knowing in advance. When a user's hard-disk files are deleted by your program, you will quickly learn the peril of allowing undefined behaviour!

Example:

int x[10] = {0, 1, 2, 4, 5, 6, 7, 8, 9];

int* p = x;

p += 10; // one-past-the-end of the array

*p = 42; // undefined behaviour!

Referring to the one-past-the-end of an array is perfectly valid. Indeed, many algorithms that operate upon arrays using a half-closed range of iterators specifically rely upon this validity to determine when the algorithm has reached the end of the sequence and should stop processing. However, we must never dereference this address even if the address is actually part of the array. Consider the following algorithm:

void scale (int* b, int* e, int scalar) {

while (b != e) {(*b) *= scalar; ++b; }

}

This algorithm operates upon any sequence of elements denoted by the half-closed range [b:e), where e refers to the element one-past-the-end of the sequence we wish to scale.

Given our earlier definition of array x, we can scale any sequential portion of the array:

scale (x, x+5, 2); // Scale the first 5 elements (x[0] through x[4]), doubling the values. scale (x+5, x+10, 3); // Scale the last 5 elements (x[5] through x[9]), tripling the values.

scale (x, x+10, 4); // Scale the entire array (x[0] through x[9]), quadrupling the values.

Note that the begin iterator, b, must initially refer to an element within the bounds of x (that is, x[0] through x[9]), but e may refer to any element in the range x[0] through x[10]. Although x[10] is outwith the bounds of x, we never actually access this element, we simply refer to it to check that b is still in range before dereferencing the element and scaling its value.

Undefined behaviour is created when we invoke this algorithm with invalid iterators:

scale (x, x+11); // Undefined behaviour! Range includes x[10] which is outwith the bounds of x. scale (x-1, x+10); // Undefined behaviour! Range includes x[-1] which is outwith the bounds of x. scale (x+9, x-1); // Undefined behaviour! Algorithm does expect reversed sequences.

Note that the algorithm is designed for efficiency and therefore does not check the given range for validity. Although inherently unsafe, efficiency often places the onus of responsibility upon the caller, never the algorithm.

Next Answer

Exceeding the range of elements in an array (or a string) is a common newbie programming error, and is considered improper or "illegal" programming practice in C or any other programming languages and the outcome of doing so is considered "undefined". That means the results cannot be predicted. Compilers attempt to catch such errors and often have options to enable/disable checking for invalid array references during program execution.

So what happens when a range is exceeded? What does undefined get you? Their are several possibilities.

• If the address is outside of your allocated address space, the system will intercept the attempt and likely terminate your program with a nasty message. Modern systems will not let an errant program violate the integrity of the system or another running program.
• If your system has separate instruction and data space capabilities, you will access some other data in your program, possibly even a stored constant and that may affect the way the rest of your programs, or not.
• If both instructions and data share the same space, you might access an actual machine instruction. If you modify that instruction, your program reaches it, and tries to do something it can't do, the system may terminated the program with a nasty message.

The following code demonstrates function overloading to calculate volumes of cubes, cylinders and rectangular boxes (cuboids).

#include // required for input/output.

#include // required for atan() function.

using namespace std; // required for console input/output.

// User-input control function (avoids garbage input).

unsigned int GetNum( char * prompt )

{

int iResult = 0;

cout << prompt << ": ";

while( !( cin >> iResult ) iResult < 0 )

{

cin.clear();

cin.ignore( BUFSIZ, '\n' ); // If BUFSIZ not defined, use literal constant 512 instead.

cout << "Please enter numeric characters only." << endl << endl;

cout << prompt;

}

return( iResult );

}

// Forward declarations of overloaded functions.

void volume(unsigned int);

void volume(unsigned int,unsigned int);

void volume(unsigned int,unsigned int,unsigned int);

void volume(unsigned int s)

{

unsigned int cube = s*s*s;

cout << "Volume of cube is " << cube << endl << endl;

}

void volume( unsigned int r, unsigned int h)

{

// For the greatest accuracy across all platforms,

// PI is defined as 4 * arctan(1).

float cylinder = (4*atan((float)1)) * r*r*h;

cout<<"Volume of cylinder is " << cylinder << endl << endl;

}

void volume(unsigned int l, unsigned int b, unsigned int h)

{

unsigned int cuboid= l*b*h;

cout << "Volume of cuboid is " << cuboid << endl << endl;

}

int main()

{

unsigned int s;

s = GetNum( "Enter side of cube" );

volume( s );

unsigned int r, h;

r = GetNum( "Enter radius of cylinder" );

h = GetNum( "Enter height of cylinder" );

volume( r, h );

unsigned int l, b;

l = GetNum( "Enter length of cuboid" );

b = GetNum( "Enter breadth of cuboid" );

h = GetNum( "Enter height of cuboid" );

volume( l, b, h );

return 0;

}

OUTPUT:

Enter side of cube: 4

Volume of cube is 64

Enter radius of cylinder: 2

Enter height of cylinder: 3

Volume of cylinder is 37.6991

Enter length of cuboid: 9

Enter breadth of cuboid: 8

Enter height of cuboid: 6

Volume of cuboid is 432

Press any key to continue . . .

[EDIT] Reasons for changes to original answer:

1. Code does not compile.
2. Code strays from the question by including a non-essential class.
3. Code is not platform-independent.
4. Code does not cater for invalid input.

Private virtual functions are useful when you expect a particular method to be overridden, but do not wish the override to be called from outside of the base class. That is, the base class implementation and its overrides remain private to the base class.

Private virtual methods are particularly useful in implementing template method patterns, where certain algorithmic steps need to be deferred to subclasses, but where those steps need not be exposed to those subclasses. In many cases the private virtual methods will be declared pure-virtual, thus rendering the base class an abstract base class.