## C Q&A #3: When ((x == x + 5) && (y != y)) is true.

The post heading gives an expression which is a contradiction and not possible. In general yes it is a contradiction, but can you write a code such that the below code prints “Hello World.” ?

```/* Add source code in the following code such that "Hello World." is printed. */

#include <stdio.h>
#include <math.h>

int main (void)
{

if (x == x + 5)
{
printf ("Hello ");
}
if (y != y)
{
printf ("World.\n");
}

return 0;
}
```

## Get sorted index orderting of an array

Yesterday i was translating some code i wrote in R to C++. I had some calculation to do which required the list of index of the top n values in a list. Therefore what i needed was not a the list sorted itself or get a sorted copy of a given list, but actually the sorted order of the index into the actual array. To describe the problem, for example consider the following list:

```arr = 20 50 40 80 10
```

The sorted (non-decreasing) ordering of the values is obviously

```sorted_arr = 10 20 40 50 80
```

The sorted (non-decreasing) ordering of the index into the original array is (index starts at 1 in this example)

```sorted_index_into_arr = 5 1 3 2 4
```

Therefore the smallest value in the list arr could be found by indexing into arr using the first value of sorted_index_into_arr, which stores the index of the array arr holding the smallest value.

```arr[ sorted_index_into_arr ]
```

The sorted index ordering is very easy to get in languages like R and Octave or Matlab. For example in R we can do the following to get the sorted index order using the order function:

```> arr <- c (20, 50, 40, 80, 10)
> arr
 20 50 40 80 10
> order (arr)
 5 1 3 2 4
```

In the case of Octave or Matlab you can get the index order using the sort function, which will return two lists (1xn matrix), the first list is the sorted array itself, and the next one is the sorted index order into the original array.

```octave:1> a = [20 50 40 80 10]
a =

20   50   40   80   10

octave:2> [sorted index] = sort (a)
sorted =

10   20   40   50   80

index =

5   1   3   2   4
```

Although these functional languages provides gives these features in C/C++ it is not immediately available using the builtin sort library functions. But the sorting routines accepts a function pointer to a comparison function, writing appropriate code for which will do the trick.
Continue reading “Get sorted index orderting of an array”

## C Q&A #2: Watch your shift!

What do you this should be the output of the below code? Is there any problem in the code?

```#include <stdio.h>

int main(void)
{
int x = -1, y = 1, a, b, c, d, e, f;

a = x << 4;
b = x >> 4;
c = y << 4;
d = y >> 4;
e = y << sizeof (int) * 8;
f = y << -4;

printf("a = %x \nb = %x \nc = %x \nd = %x \ne = %x \nf = %x",a, b, c, d, e, f);

printf ("\n");
return 0;
}
```

## C Q&A #1: How many bits are there in a byte?

The question is simple: How many bits are there in a byte. But the answer is not that straight, there is a “but” after the answer we all know.

## C Q&A #0: Returning address of local variable

The below code is given. You need to determine what the output will be, or if there is an error.

```#include<stdio.h>

int main()
{
int *j;
int *fun();
j = fun();
printf("%d\n",*j);
printf("%d",*j);
return 0;
}

int *fun()
{
int k = 35;
return(&k);
}
```

## Using scanf safely

Beginners find that the scanf function behaves strangely when you input a character when scanf expects an integer or float. When used inside a loop (taking options), it loops infinitely. Here is a short post which explains what it happens, and how to solve this,

## Accessing private data members directly outside from its class in C++

Private members in C++ cannot be accessed from outside the class directly. In this post I will tell an interesting fact, that in C++ however there are means with which you can access/modify the values of the private members of a class from outside of the class, when the structure of the class is known.

## Input Strings with Blankspaces

In CLI programs getting input from the standard input is very important. Often we need to input strings from the user. Strings are delimited by newline, blankspace character and other characters as per the user interpretation. I am discussing on some ways here with which we can take input strings with blankspaces in it safely.
Continue reading “Input Strings with Blankspaces”

## Allocating multidimentional array at runtime in C

Arrays in C language are static in nature, and cannot be resized at runtime. The effect of runtime allocation of an array could be achieved by hierarchically allocating blocks of memory at runtime. Below we discuss the mechanism to allocate multidimensional arrays.
Continue reading “Allocating multidimentional array at runtime in C”

## C Language Constructors and Destructors with GCC

Constructors and Destructors are special functions. These are one of the features provided by an Object Oriented Programming language. Constructors and Destructors are defined inside an object class. When an object is instantiated, ie. defined of or dynamically allocated of that class type, the Constructor function of that class is executed automatically. There might be many constructors of which the correct implementation is automatically selected by the compiler. When this object is destroyed or deallocated, the Destructor function is automatically executed. For example when the scope of the object has finished or the object was dynamically allocated and now being freed. The Constructors and the Destructors are generally contains initialization and cleanup codes respectively required by an object to operate correctly. Because these functions are automatically invoked by the compiler therefore the programmer freed from the headache of calling them manually.