Dynamic Memory allocation is done by using the keyword “new” in c++. When creating dynamic memory a pointer is always needed.  Let us start by looking at one very simple example. (the code below does not deallocate memory which I will get to next.)

main(){

int* iPtr;
iPtr = new int;
*iPtr = 10

cout << *iPtr << endl

}

so there you have it, a simple dynamically allocated int. The program above does not give us any advanges, but I used it since its a good example for learning purposes.

Deallocating memory

It is very important to give the memory back to the OS after we are done with the memory we need. Memory is given back to the OS by using the keyword “delete”. It is very simple to use, in the example I did not deallocate memory back to the OS, which makes it unusable until the OS is restarted.  Here is an modified version of the program above which deallocates memory.

main(){

int* iPtr;
iPtr = new int;
*iPtr = 10

cout << *iPtr << endl

delete *iPtr //simply remove the allocated memory pointed by *iPtr

}

template <template T>
void swap(T a, T b){
T temp;
temp = a;
a = b;
b = temp;
}

we the function template above, we can pass it an int or float and the compiler will automatically create separate functions as needed.

int A = 5;
int& rA = A;

cout << rA << endl;

A = 7;

cout << rA << endl;

Output:

5

7

No matter which variable’s value gets changed both A and rA change.

References can be used to replace pointers in some cases. As you may recall functions in c/c++ can only return one value and programmers use pointers in order to get around that! References can be used instead of pointers and you do not have to use the * operator in your functions.

You can code the rm, cp, ect commands in no time. Here is a sample code which you can use to understand passing arguments.

int main(int argc, char* argv[]){
  int i;
  for(i = 0;i<argc; i++){
    printf("%d: %s\n", i+1, argv[i]);
  }
  return 0;
}

argc is the number of arguments being passed in, and argv is a char pointer array which has the arguments.

Here is an example of enum.

#include
int main()
{
enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

Days TheDay;
int j = 0;
printf("Please enter the day of the week (0 to 6)\n");
scanf("%d",&j);
TheDay = Days(j);

if(TheDay == Sunday || TheDay == Saturday)
printf("Hurray it is the weekend\n");
else
printf("Curses still at work\n");

return 0;
}

One thing to keep in mind is that enums start from 0 so in the following line of code

enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

Sunday is assigned 0, Monday is assigned 1 and so on..

It is possible to make them start at a different number if we assign a number to it as shown below.

enum Days{Sunday = 1,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

In the example above, Sunday would have the value 1, Monday would have 2 and so on….

Feel free to ask any questions in the comment box below.

Anyone can start using pointers to functions all you have to do is to understand what they are and to learn its syntax.

What is a Function Pointer?

Function pointers are simply pointers that point to a function! Functions have addresses in memory just as variables do.

Syntax

The syntax can be a little strange if you are seeing for the first time but its very easy to grasp.

Suppose we have the following function


int add(int a, int b){
return a+b;
}


we can start creating a pointers to function by writing

int (*fptr)(int, int);

int is the return type of the function and (int, int) is the arguments the function accepts.

The next step is to give our pointer to function the function’s address. We do that with the following code

fptr = add;


Now that fptr points to the “add” function we can actually start calling out function using the fptr pointer. We use the code below to do it.


int c = 0;
c = (*fptr)(a, b);


As you can see pointers functions are easy to learn I will make more posts soon to show how you can get rid of a long switch statement by using pointers to functions. I have also posted a compilable example below so you can experiment with.


/* Author: Fardad Soleimanloo */
#include
int add(int a, int b){
return a+b;
}
int main(){
int (*fptr)(int, int);
int a = 10;
int b = 20;
int c;
fptr = add;
c = (*fptr)(a, b);
printf("%d\n", c);
return 0;
}



#include <stdio.h>

int main(){
int number[10] = {5, 1, 8, 3, 6, 5, 3, 8, 4, 6};
int i = 0;
while(i < 10){ if(number[i] > 5)
printf(“%d\n”, number[i]);
i++;
}
return 0;
}

The above program takes 0m0.004s to execute.

The program below is using “AND” instead of if statement


#include <stdio.h>

int main(){
int number[10] = {5, 1, 8, 3, 6, 5, 3, 8, 4, 6};
int i = 0;

while(i < 10){ number[i] > 5 && printf(“%d\n”, number[i]);
i++;
}
return 0;
}

The program above executes in 0m0.003s

Using AND can have some performance advantage over if statements, but it is only faster by a tiny amount.


int number = 4;
int* pNumber = &number;


int* pNumber = &number creates an integer pointer and assigns number’s address to it. In C/C++ the character ‘&’ means the “address of”. The simple program below will give you a better understanding of addresses.


#include <stdio.h>


int main()
{
int number = 4;
int* pNumber = &number;
printf(“%u, %u\n”, &number, pNumber);

return 0;
}

The output would be:

3214459548, 3214459548

Have a look at the program below and determine what the value of “ch” would be without running the program.

#include <stdio.h>

int main(){

char ch = 127;
ch++;

return 0;
}

What would the value of ch be when the program is executed? Most people would guess it would be 128, but the right answer is -128.

The reason behind it is because a signed char type in c/c++ only accepts values from -128 to 127 and when ch++ is executed 127 goes to the next avaialble number which is -128.