FUNC.CPP

• 1: #include <iostream.h>


• 2: int Add (int x, int y) {4:


• 3: cout << "In Add(), received " << x << " and " << y << "\n";


• 4: return (x+y); }


• 5: int main() { cout << "I'm in main()!\n";


• 6: int a, b, c;


• 7: cout << "Enter two numbers: ";


• 8: cin >> a;


• 9: cin >> b;


• 10: cout << "\nCalling Add()\n";


• 11: c=Add(a,b);


• 12: cout << "\nBack in main().\n";


• 13: cout << "c was set to " << c;


• 14: cout << "\nExiting...\n\n";


• 15: return 0; }


Output: 


• I'm in main()!
 
• Enter two numbers: 3 5
 
• Calling Add()
 
• In Add(), received 3 and 5
 
• Back in main().
 
• c was set to 8
 
• Exiting... 

Demonstrating call to a function

• 1: #include <iostream.h>
 
• 2: // function Demonstration Function
 
• 3: // prints out a useful message
 
• 4: void DemonstrationFunction()
 
• 5: { cout << "In Demonstration Function\n"; }
 
• 6: // function main - prints outa message, then
 
• 7: // calls DemonstrationFunction, then prints
 
• 8: //out a second message.
 
• 9: int main() { cout << "In main\n" ;
 
• 10: DemonstrationFunction();
 
• 11: cout << "Back in main\n";
 
• 12: return 0; } 

Output for Function call : 

• In main
 
• In Demonstration Function
 
• Back in main  

Using cout

Cout is a function as like as printf. We use cout in c++ and printf in C. Cout is easy to use. 

• 1: #include <iostream.h>
 
• 2: int main()
 
• 3: { cout << "Hello there.\n";
 
• 4: cout << "Here is 5: " << 5 << "\n";
 
• 5: cout << "The manipulator endl writes a new line to the screen." <<endl;
 
• 6: cout << "Here is a very big number:\t" << 70000 << endl;
 
• 7: cout << "Here is the sum of 8 and 5:\t" << 8+5 << endl;
 
• 8: cout << "Here's a fraction:\t\t" << (float) 5/8 << endl;
 
• 9: cout << "And a very very big number:\t" << (double) 7000 * 7000 << endl;
 
• 10: cout << "Don't forget to replace Jesse Liberty with your name...\n";
 
• 11: return 0;}

Output using cout: 

•Hello there.
 
•Here is 5: 5
 
• The manipulator endl writes a new line to the screen.
 
• Here is a very big number: 70000
 
• Here is the sum of 8 and 5: 13
 
• Here's a fraction: 0.625
 
• And a very very big number: 4.9e+07
 
• Don't forget to replace Jesse Liberty with your name...
 • Jesse Liberty is a C++ programmer! 

58. Evolution of C++

• C was extended to create C++ by Bjarne Stroustrup


• Features needed to facilitate object-oriented programming was provided in C++


• C++ is the predominant language for commercial software development


• C++ is a superset of C. The leap from C to C++ is very significant


• Any legal C program is a legal C++ program.


• To get the full benefit of C++, programmers need to learn a new way of
conceptualizing and solving programming problems

57. Four Pillars of Object-Oriented Programming

* Encapsulation 
* Data Hiding
* Inheritance
* Polymorphism

C++ Fully supports object-oriented programming.

Encapsulation: -Being a self contained unit.

Data hiding: -An object can be used without knowing about its internal data members.

Encapsulation and Data Hiding:

* C++ supports encapsulation and data hiding through
* The creation of user-defined types, called classes.
* A well-defined class acts as a 

  -  Fully encapsulated entity--it is used as a whole unit.
  - The actual inner workings of the class are hidden.
  - Users of a well-defined class do not need to know how the class works.
  - They just need to know how to use it.

Inheritance and Polymorphism: 

* Inheritance
 
  - a new object type, which is an extension of an excising type can be declared
  - This new subclass is said to derive from the existing type and is sometimes called a derived type.
  - C++ supports reuse through inheritance.

* Polymorphism
 
  - refers to the same name taking many forms.
  - C++ Supports the idea that different objects do "the right thing" through.
  - Function polymorphism and class  polymorphism

56. Difference between pointer and reference

POINTER

1.   Its not necessary to initialize the pointer at the time of declaration. Like

      Code:

     int a=10;

     int *p=&a; //it is not necessary

Another way is:

   Code:

   int a=10;

   int *p;

   p=&a;

2.   You can create the array of pointer.

3.   You can assign NULL to the pointer like

   Code:

   int *p=NULL; //valid

4.   You can use pointer to pointer.

REFERENCE:

1.   Its necessary to initialize the Reference at the time of declaration. Like

      Code:

      int &a=10

      int &a; //Error here but not in case of pointer.

2.   You can not create the Array of reference.

3.   You can not assign NULL to the reference like.

    Code:

    int &a=NULL; //Error

4.   You can not use reference to reference.

55. Difference between C and C++

Ø  In case of C, the data is not secured while the data is secured(hidden) in C++

Ø  C is a low-level language while C++ is a middle-level language

Ø  C is function-driven while C++ is object-driven

Ø  C++ supports function overloading while C does not

Ø  We can use functions inside structures in C++ but not in C.

Ø  The NAMESPACE feature in C++ is absent in case of C

Ø  The standard input & output functions differ in the two languages

Ø  C++ allows the use of reference variables while C does not

54.Difference between class and structure

1.   Classes are usually used for large amounts of data, whereas structs are usually used for smaller amount of data.

2.   Classes could be inherited whereas structures no

3.   A structure couldn't be Null like a class.

4.   A structure couldn't have a destructor such as class.

5.   A structure can't be abstract, a class can.

6.   You can't use sizeof with classes but you can with structures.

7.   The structure can't contain a volatile field wheatears the class does.

8.   classes support polymorphism, whereas structures do not.

51. Inline function

Inline functions are an imperative feature of C++ and are frequently used with classes. Inline functions are functions where the call is made to inline functions. The actual code then gets placed in the calling program. In a program when we call a function the program jumps to the address of the function and when it reaches the end of the function it comes back. This jumping actually involves much more and takes time. But when an inline function is called the compiler will replace the call with the function code. So in reality in that place there will be no function call, only the code of the function. No jumping needed to different addresses. The general format of inline function is as follows:

inline datatype function_name(arguments)

Example:

The following code creates and calls an inline function:

#include<iostream.h>

inline int average(int a, int b)
{
   return (a + b) / 2;
}

void main()

{
   int result = average(12, 14);

   cout << "The average of number 12, 14 is " << result << "\n";

   getch();

}

It is most important to know that the inline specifies is a request, not a command, to the compiler. If, for various reasons, the compiler is unable to fulfill the request, the function is compiled as a normal function.

50. What is macros in C

A macro is a fragment of code which has been given a name. When we use the name of macro in program, it is replaced by the contents of the macro. You may define any valid identifier as a macro, even if it is a c keyword. There are two types of macros. One is object-like macros and another is function-like macros. Object-like macros do not take parameters; function-like macros do. The generic syntax for declaring an identifier as a macro of each type is:

For object-like macros:

 #define <identifier> <replacement token list>

For example:

#include<stdio.h>

#include<conio.h>

#define sum a+b

void main()

{

Clrscr();

int a=5,b=10,c;

c=sum; //if we give the semicolon (;)when we define the macro; then we cannot give the semicolon when we write the name of identifier. If we give the semicolon when we define the macro, then we give the semicolon when we write the name of identifier in program

printf(“The sum of a+b is: %d”,c);

getch();}

For function-like macros:

#define <identifier> (<parameter list>) <replacement token list>

For example:   

#include<stdio.h>

#include<conio.h>

#define square(x) x*x;

Void main()

{

Clrscr();

int i=2,j;

j=square(i) //Here is no semicolon because I give the semicolon when I define the macros.

printf(“The value of j is: %d”,j);

getch();
}

 The #undef directive removes the definition of a macro.

Written by arnob;