C++ Programming

A conventional base class is a class that has a virtual destructor. Virtual destructors are important in most class hierarchies because while we may not always know the exact type of the most-derived class in a hierarchy, we will always know at least one of its base classes. If we destroy that base, it is reasonable to expect the entire object to be destroyed, not just the base, and this can only be achieved with a virtual destructor.

Note that a virtual destructor must be declared in the least-derived class in the hierarchy to ensure correct polymorphic behaviour.

Classes not intended to be used as base classes do not have virtual destructors. This does not mean they cannot be used as base classes, but if you choose to use them as base classes you must be aware of the "unconventional" problems that can arise, particularly when destroying objects through pointers or references to their base classes as will lead to resource leaks.

If you do not wish a class to be used as a base class, then the class should be declared final (since C++11). All other classes can still be used as base classes, however only classes with virtual destructors behave polymorphically.

Typically, if we define at least one virtual function in a class, we should also define a virtual destructor for that class. However, derived classes implicitly inherit virtual destructors from their bases thus the absence of a virtual destructor in a derived class should not be taken to mean the derived class is not intended to be used as a base class; always look at the least-derived class definition to determine if a virtual destructor exists or not.

Along with the final specifier, the overridespecifier was also introduced in C++11. This makes it much easier to document virtual functions and their overrides. That is, we can use the virtual specifier solely to introduce a new virtual function into the class hierarchy, and use the overridespecifier to show that we are explicitly overriding a virtual function rather than simply introducing a new virtual function. We can also use the final specifier to indicate that an individual virtual function cannot be overridden any further:

struct X {

virtual void f ();

virtual ~X ();

};

struct Y : X {

void f () override; // implies X::f() is either virtual or is itself an override

~Y () override; // implies ~X() is virtual or is itself an override

};

struct Z : Y {

void f () override; // implies Y::f() is either virtual or is itself an override

~Z () override; // implies ~Y() is virtual or is itself an override

};

The override and final keywords are only useful if used consistently. However, being part of the language itself means we can now enlist the help of the compiler to catch subtle errors that couldn't be easily caught before:

struct X {

void f () override; // error! X did not inherit an f () thus it cannot be an override!

virtual void g (); // ok

virtual ~X(); // ok

};

struct Y : X {

void g () override final; // ok

~Y () override; // ok

};

struct Z : Y {

void g () override; // error! Y::f() is declared final -- it cannot be overridden!

~Z () override; // ok

};

struct Z2 : Z final {}; // ok

struct Z3 : Z2 {}; // error: Z2 is final -- cannot be used as a base class!

The problem with generating Fibonacci numbers is that they get large very fast. They will eventually exceed the range of even 64 bit integers. In C++, one way to solve this issue is to write a dynamic, arbitrary decimal class.

You could create a linked list, where each element represents a digit. The first element is the units digit, the second the tens digit, the third the hundreds digit, and so forth.

Imbed this linked list into a decimal number class, and provide operators to do various math operations such as addition between two instances of the class. When implementing operator+, for instance, iterate through the elements of both classes, adding them, and applying the carries in each step. If need be, invoke the AddDigit method of the linked list to make the r-value larger by one digit.

With this class, implementing construct, destruct, copy, assign, add, and print, you can generate a Fibonacci sequence using the algorithm of keeping three numbers, and iterating each sequence by adding the prior two numbers and then moving numbers around. (More efficient would be to rotate pointers to the three instances, rather than copying them.) As the instances get reused, it would also be helpful if you did not just delete elements, but, rather, allowed for them to be reused by keeping track of how many are in use versus how many are allocated. (Or you could just zero the excees digits. That is your choice, and it is part of your overall design. Keep in mind that you do know how long the list is, by knowing which element is the last element.)

As you develop this class, you will find more uses that involve other operations, such as multiply and divide. You can extend the class as necessary.

The following example demonstrates a very basic implementation that will generate Fibonacci numbers up to a given length (200 digits in the example, but you could easily generate arbitrary length from user input). The program can also be easily adapted to produce the nth Fibonacci. The implementation of the bignum class could be improved enormously by embedding a pointer to std::vector and implementing a move constructor (like a copy constructor, but ownership of the resources is swapped rather than shared). Also, storing one character per element is highly inefficient, it would be far better to store multiple digits in 64-bit elements. However I've kept the class as simple as possible for the purpose of clarity.

#include

#include

class bignum

{

friend std::ostream& operator<<(std::ostream& os, const bignum& n);

public:

bignum(unsigned int n=0);

bignum operator+(const bignum& );

size_t size()const{return(list.size());}

private:

std::list list;

};

bignum::bignum(unsigned int n)

{

if( n )do

{

unsigned char digit=n%10;

list.push_front( digit );

} while( n/=10 );

}

bignum bignum::operator+(const bignum& n)

{

bignum result;

unsigned char carry=0, digit=0;

std::list::const_reverse_iterator first = list.rbegin();

std::list::const_reverse_iterator second = n.list.rbegin();

while( first!=list.rend() second!=n.list.rend() carry )

{

digit=carry;

if( first!=list.rend() ) digit+=*first++;

if( second!=n.list.rend() ) digit+=*second++;

carry=digit/10;

digit%=10;

if( digit first!=list.rend() second!=n.list.rend() carry )

result.list.push_front( digit );

}

return( result );

}

std::ostream& operator<<(std::ostream& os, const bignum& n)

{

if( !n.list.size() )

os<<'0';

else for( std::list::const_iterator it=n.list.begin(); it!=n.list.end(); ++it )

os<<(unsigned int)*it;

return( os );

}

int main()

{

bignum* num1 = new bignum(0); std::cout<<*num1<

bignum* num2 = new bignum(1); std::cout<<*num2<

// generate the Fibonacci sequence up to a length of 200 digits

while(num2->size()<200)

{

bignum* num3 = new bignum( *num1+*num2 );

delete(num1);

num1 = num2;

num2 = num3; std::cout<<*num2<

}

delete( num2 ); num2 = NULL;

delete( num1 ); num1 = NULL;

std::cout<

}

A char is a single character. A String is a collection of characters. It may be empty (zero characters), have one character, two character, or many characters - even a fairly long text.

The single quote (') is used to deliniate a character during assignment:

char someChar = 'a';

The double quote (") is used to delineate a string during assignment:

String someString = new String("hello there");

Note that char is a primitive data type in Java, while String is an Object. You CANNOT directly assign a char to a String (or vice versa). There is, however, a Character object that wraps the char primitive type, and Java allows method calls to be made on the char primitive (automagically converting the char to Character before doing so).

i.e. these ALL FAIL:

someString = SomeChar;

someString = new String(someChar);

However, these WILL work:

someString = Character.toString(someChar);

someString = someChar.toString();

Also note that a String is a static memory allocation, while a character's is dynamic. By that, I mean that when a String is created, it is allocated a memory location exactly big enough to fit the assigned string. Any change to that String forces and entirely new memory location to be allocated, the contents of the old String copied in (with the appropriate changes), and the old String object subject to garbage collection. Thus, making changes to a String object are quite inefficient (if you want that kind of behaviour, use StringBuffer instead).

A character is allocated but once; all subsequent changes to a character variable simply overwrite that same memory location, so frequent changes to a character variable incur no real penalty.

STEP1. Set value of count=1, output=1, T1=0, T2=1

STEP2. Read value of n

STEP3. Print output

STEP4. Calculate

output=T1+T2

STEP5. T1=T2 & T2=output

STEP6. Calculate count= count+1

STEP7. If (count<=n>

go to STEP3

else

go to STEP8

STEP8. End

You could also just plug in n into this formula:

F(n) = [φ^n - (1-φ)^n] / sqrt(5)

φ is about 1.618033989 and is the Golden Ratio

[It's also the limit as n approaches infinity of the nth term in the Fibonacci sequence divided by the (n-1)th term]

The fundamental built in data types in C++ are integral (char, short, int, and long) and floating (float, double, and long double1).

The fundamental derived data types in C++ are arrays, functions, pointers, and references.

The composed derivative data types in C++ are classes, structures, and unions.

----------------------------------------------------------

1Microsoft specific ??

Virtual means that decision would be taken at another stage... first base class constructor is called and construction of object cannot be held anonymous. that's y virtual constructors are not possible.

In object oriented programming main role plays objects and classes, in structure programming all programmes are represented as structures of block's, in procedure programming - that means high level programming languages, which are based on process description (sequence of processes) - all programmes are described like a set of subprogrammes or procedures.

For more information you may search these articles:

http:/en.wikipedia.org/wiki/Object-oriented_programming

http://alarmingdevelopment.org/?p=9

http:/en.wikipedia.org/wiki/Procedural_programming

A constructor differs from a normal member function in three ways:

1. A constructor never returns a result. The constructor's declaration reflects this by not even declaring the function as "void."

   The common design hypothesis is that a well-designed constructor cannot fail, other than maybe in an irrecoverable way (such as a fatal running out of memory).

2. A constructor is never called explicitly except with the new operator.
3. Constructors impose further restrictions. For example, they cannot be declared abstract or virtual, and may have visibility requirements.

   The common design practise is that at least the default constructor is declared public.

A virtual function in C++ is a function that can have multiple definitions.

For example:

If you have a class which contains a virtual function:

class Virtual

{

virtual void makesomething();

};

That function can be implemented when you inherit that class an implement the function. So:

class Inherit : public Virtual

{

//this is the same function, but can be implemented to do something different

void makesomething() { //do something else }

};