Welcome to EGSoftWeb

For example:

namespace mycode {

     float pi = 3.1415;

     int factorial(int number)

     {

           if (number)

                return factorial(number - 1) * number;

           else

                return 1;

     }

}

int factorial(int number)

{

     int ret=1;

     for (int i = 1; i <= number; i++)

           ret = ret * i;

     return ret;

}

#include <iostream>

int main()

{

     std::cout << "factorial of 7 using recursive method = " << mycode::factorial(7) << "\n";

     std::cout << "area of circle of radius 1 is " << mycode::pi * 1 * 1 << "\n";

     std::cout << "factorial of  7 using for loop = " << factorial(7) << "\n";

     return 0;

}

Here we defined the namespace named as mycode and inside of it we defined a float variable pi and a function factorial and used these in the main function. A same named function of factorial is defined outside the namespace and we can easily call this without any name collision.

There is not any feature of namespace in C.

Multiple namespace with same name can be used in the code, all will follow same namespace and all declaration of identifiers can be used with the same name. For example:

namespace const_pi {

     float pi = 3.14156;

     float multiply2(float n) { return 2 * n; }

}

namespace  const_pi {

     float pi_2 = multiply2(pi);

}

namespace const_pi {

     float pi_4 = multiply2(pi_2);

}

#include <iostream>

int main()

{

     std::cout << "value of pi = " << const_pi::pi << "\n" ;

     std::cout << "value of 2*pi = " << const_pi::pi_2 << "\n";

     std::cout << "value of 4*pi = " << const_pi::pi_4 << "\n";

     return 0;

}

namespace can be defined only at global scope. (We cannot define a namespace in function/class etc.

Nested namespace are allowed. For example:

namespace n1 {

     int value = 1;

     namespace n2 {

           int value = 2;

           namespace n3 {

                int value = 3;

                namespace n4 {

                      int value = n1::value * n2::value * n3::value;

                }

           }

     }

}

#include <iostream>

int main()

{

     std::cout << "value in the namespace n4 is " << n1::n2::n3::n4::value;

     return 0;

}

using namespace:

See below 2 examples:

//Example1

#include <iostream>

int main()

{

     std::cout << "we are using std namespace without \"using\" keyword :)";

     return 0;

}

//Example2

#include <iostream>

using namespace std;

int main()

{

     cout << "we are using std namespace with \"using\" keyword :)";

     return 0;

}

Note: The definition of std namespace is in the header file <iostream>

Both example compile and execute without any problem.

Now see below examples:

//Example1

#include <iostream>

#define print(str) std::cout << str << "\n"

namespace ns1 {

     int value = 1;

}

namespace ns2 {

     int value = 2;

}

int main()

{

     print(ns1::value);

     print(ns2::value);

     return 0;

}

//Example2

#include <iostream>

#define print(str) std::cout << str << "\n"

namespace ns1 {

     int value = 1;

}

namespace ns2 {

     int value = 2;

}

using namespace ns1;

using namespace ns2;

int main()

{

     print(ns1::value);

     print(ns2::value);

     return 0;

}

//Example3

#include <iostream>

#define print(str) std::cout << str << "\n"

namespace ns1 {

     int value = 1;

}

namespace ns2 {

     int value = 2;

}

using namespace ns1;

using namespace ns2;

int main()

{

     print(value);

     return 0;

}

The Example1 and Example2 compile and execute without any problem, but Eample3 will not compile and show error as "value" is ambiguous”.

The line #include <iostream> includes the declarations of the standard

stream Input/Output facilities as found in <iostream>.

The std:: specifies that the name cout is in the standard-library namespace (we will discuss namespace on following blog, just forget it for now).

Below code sample take an integer number from user input and show its square and cube.

1)      C++ was invented by Bjarne Stroustrup in 1980 at AT&T lab while adding Object-oriented constructs to the C language.

2)      C++ is a General purpose OOP (Object –Oriented Programming) language.

3)      C++ is a middle-level language, because it has both high and low level language features.

4)      C++ is a best programming language for computer hardware interaction, a lot of control hardware, memory management, better performance etc.

5)      C++ was initially called as “C with classes”, so we can say C++ is an expanded version (new version) of C.

6)      Every C program can be compiled as C++ but not every C++ code is a C program.

7)      C++ supports both procedural and OOP concept, so it can also called as hybrid programming language.

8)      The Object-Oriented Approach has following features or properties

(i)                  Abstraction

(ii)                Encapsulation

(iii)               Polymorphism

(iv)               Inheritance

We will discuss these terms on following blogs.

This is very short introduction, but just enough for remembering about “C++ introduction”.

If size of array we declared is not fix, then we can allocate memory manually during run-time using inbuilt function like malloc, alloc etc.

This is known as dynamic memory allocation.

There are 4 library functions defined in <stdlib.h> makes dynamic memory allocation in C programming. These are malloc(), calloc(), realloc() and free().

1) malloc() - The name "malloc" stands for memory allocation.

The malloc() function reserves a block of memory of the specified number of bytes. And, it returns a pointer of type void which can be casted into pointer of any form.

Syntax of malloc():

ptr = (cast_type*) malloc(byte_size)

Considering the size of int is 4 bytes, this statement allocates 400 bytes of memory. And, the pointer ptr holds the address of the first byte in the allocated memory.

However, if the space is insufficient, allocation fails then returns a NULL pointer.

2) calloc() - The name "calloc" stands for contiguous allocation.

The malloc() function allocates a single block of memory. Whereas, calloc() allocates multiple blocks of memory and initializes them to zero.

Syntax of calloc()-

ptr = (cast_type*)calloc(n, element_size);

This statement allocates contiguous space in memory for n elements each with the size of element_size.

3) free() - Dynamically allocated memory created with either calloc() or malloc() doesn`t get freed on their own. We must use free() to release the space.

Syntax of free()-

free(ptr);

This statement frees the space allocated in the memory pointed by ptr.

4) realloc() - If the dynamically allocated memory is insufficient or more than required, we can change the size of previously allocated memory using realloc() function.

Syntax of realloc()-

ptr = realloc(ptr, x);

Here, ptr is reallocated with new size x.

Examples:

A function has a physical location in memory that can be assigned to a pointer. This address is the entry point of the function and can be used when the function is called. Once a pointer points to a function, the function can be called with help of that pointer. Function pointers also allow functions to be passed as arguments to other functions.

Example:

A pointer that does not currently point to a valid memory location is given the value null (which is zero). Null is used because no object will exist at the null address. Thus, any pointer that is null means that it points to nothing and should not be used.

One way to give a pointer a null value is to assign zero to it.

For example

char *p = 0;

or we can use NULL macro which is already defined to 0 in <stdio.h> header file.

The below code compiles successfully

int main()

{

     int *p;

     getchar();

     return 0;

}

But when we use the pointer it generates compile time error that “uninitialized local variable `p` used”. See below example:

#include <stdio.h>

int main()

{

     int *p;

     printf("%p", p);

     getchar();

     return 0;

}

For this, we can just initialize the pointer to a null value. The above code compile successfully if we initialize the pointer to 0;

#include <stdio.h>

int main()

{

     int *p = 0;

     printf("%p", p);

     getchar();

     return 0;

}

It shows the following output

00000000

We can make a pointer point to another pointer that points to a target value.

For example:

int **x;

[Note:  these are same.

int ** x;

int** x;

int **x;

]

This situation is called multiple indirection, or pointers to pointers.

In the case of a pointer to a pointer, the first pointer contains the address of the second pointer, which points to the object that contains the desired value.

Multiple indirections can be carried on to whatever extent desired, but more than a pointer to a pointer is rarely needed. Excessive indirection is difficult to follow and may generate errors.

To access the target value indirectly pointed to by a pointer to a pointer, we must apply the asterisk operator twice.

For example: 

Basically, we can say pointer and array are same in the nature but different in notation.

There is a close relationship between pointers and arrays.

Let s is an array of 10 integers. We define 5^th element of this array as equal 17. Now if we take a pointer to integer p and set it equal to s then we can access all element of array s from p. 5^th element of array will be *(p+5).

For example:

#include <stdio.h>

int main()

{

     int *p, s[10]; /* here by default all elements in array s are 0*/

     s[5] = 17; /* set 5th element to 17 */

     p = s; /* setting first element address to p */

     printf("%d", *(p + 5)); /* prints 17 */

     getchar();

}

Pointer Arithmetic:

Increment and decrement of pointers:

Suppose,

int x = 17;

int *p;

Now if x has stored in memory address 003FFC01, then p = &x sets the value 003FFC01 in p;

Suppose int takes 2 bytes for storing a value, then

p++;

sets the value  003FFC03 in p.

The same is true for decrement.

For example, assuming that p has the value 003FFC03, the expression

p--;

causes p to have the value 003FFC01.

Pointer Comparisons:

We can compare two pointers in a relational expression.

For example:

if (p < q) printf("p points to lower memory than q\n");