signed/unsigned comparability

An interesting post i found on linkedin

I am working on removing the compilation warnings of an old code, and I'm facing a lot of signed/unsigned comparation problems.
Then I had this doubt:

when you do:

signed int sigInt;
unsigned int uInt;

if ( sigInt > uInt ) ...

Will the expression be evaluated as both were unsigned, or is it platform specific?

I've made a simple test:

int x = -1;
unsigned int y = 10;

if ( x > y )
{
printf("xxx");
}
else
{
printf("yyy");
}

and it prints "xxx". But, when I've changed the "x" and "y" to:


signed char x = -1;
unsigned char y = 10;

it prints "yyy".

So I was wondering: how is the compiler supposed to work in this situation.

In the first case, the *standard conversion* from int to unsigned int is defined. In the second case, the signed char gets *promoted* to int. It is best to stay with a simple "int" (without signed or unsigned prefixed) and a simple "char" (without the prefixed "signed" or "unsigned") to side-step these kinds of problems.

 Yes, in the second case, the *promotion* is defined as well, the unsigned the signed and unsigned chars get converted to int. So, in this case as well, *both* x and y get converted to int and only then the comparison is done - which correctly prints "yyy".

There was a typo in my last post - I see it only now: "the unsigned the signed and unsigned chars get ..." should read as "the signed and unsigned chars get converted ...". 

This is all document in Stroustrup book - much of the stuff can be found in appendix but you'll also find bits and pieces in the main text.

Sorting Algorithm Handy Guide

Analysis of Sorting Algorithms:


STABILITY: Ability to maintain the relative Ordering(Duplicates in Data) of the input Data.
IN PLACE: Ability to perform the algorithm on the input data Memory, Not using extra Memory.
Time Complexity.

Sorting	STABILITY	IN PLACE	TIME COMPLEXITY
			Best Case	Average Case	Worst Case
Insertion Sort	Yes	Yes	O(n)	O(n^2)	O(n^2)
Bubble Sort	Yes	Yes	O(n)	O(n^2)	O(n^2)
Selection Sort	Yes	Yes	O(n^2)	O(n^2)	O(n^2)
Quick  Sort	NO	Yes	O(nlogn)	O(nlogn)	O(n^2)
Merge Sort	YES	NO	O(nlogn)	O(nlogn)	O(nlogn)
Heap Sort	NO	NO	O(nlogn)	O(nlogn)	O(nlogn)

const member function in C++, pointers and const in c++

In the below example we see that a function declared as const member of a class allows us to modify the contents of data member of the class. A brief explanation about the const member functions and const pointers are given in order to understand the behavior of the const Member Functions().

class String
{

    private:
        char* rep;

    public:
        String (const char*);
        void toUpper() const;
};

String :: String (const char* s)
{
    rep = new char [strlen(s)+1];
    strcpy (rep, s);
}

void String :: toUpper () const
{
    for (int i = 0; rep [i]; i++)
    rep[i] = toupper(rep[i]);
}

int main ()
{
    const String lower ("lower");
    lower.toUpper();

    cout << lower << endl;
    return 0;
}

A const member function, is a member function that does not mutate its member variables.

const on a member function does not imply const char *. Which would mean that you can't change the data in the address the pointer holds.

Your example does not mutate the member variables themselves.

A const on a member function, will ensure that you treat all of your member variables as const.

That means if you have:

int x;
char c;
char *p;

Then you will have:

const int x;
const char c;
char * const p; //<-- means you cannot change what p points to, but you can change the data p points to

There are 2 types of const pointers. A const member function uses the one I've listed above.

---

So the lesson to learn here is that the const keyword on member functions does not ensure that your object will not change at all.

It only ensures that each member variable will be treated as const. And for pointers, there is a big diff between const char * and char * const.

In the following statement, pOne is a pointer to a constant integer. The value being pointed to can’t be changed:

const int * pOne; // pointer to a constant integer

In this next statement, pTwo is a constant pointer to an integer. The integer can be changed, but pTwo can’t point to anything else:

int * const pTwo; // constant pointer to an integer

In this third statement, pThree is a constant pointer to a constant integer. The value being pointed to can’t be changed, and pThree can’t be changed to point to anything else:

const int * const pThree; // constant pointer to a constant integer

The trick to keeping this straight is to look to the right of the keyword const to find out what is being declared constant. If the type is to the right of the keyword, the value is constant:

const int * p1; // the int pointed to is constant

If the variable is to the right of the keyword const, the pointer variable itself is constant:

 int * const p2; // p2 is constant, it can’t point to anything else

Most of the time a const member function will mean that the member function will not modify the object itself, but this is not always the case, as the above example shows.