Example,

class Memory
{
public:
    Memory()
    {
        cout << "Constructor called" << endl;
    }

    ~Memory()
    {
        cout << "Destructor called" << endl;
    }
};

The call,

// Guarantee to call constructor
Memory *mem = new Memory();

is completely different from

// Note the paranthesis and size_t type argument, no constructor call
Memory *mem = operator new(sizeof (Memory));

The second form is similar to malloc(). We *may* use free() on such allocation. Same holds for delete.

Please correct me if I am wrong.

We know that the negative number is represented in 2’s complement form on most of the architectures. We have the following lemma hold for 2’s complement representation of signed numbers.

Say, k is numerical value of a number, then

~k = -(k+1) [ ~ is for bitwise complement ]

(k + 1) is due to addition of 1 in 2’s complement conversion

To get (k + 1) apply negation once again. So, the final expression becomes

inline
int increment(int x)
{
    return (-(~x));
}

inline
int decrement(int x)
{
    return (~(-x));
}

Example, assume the machine word length is one *nibble* for simplicity.
And k = 2 (0010),
~k = ~2 = 1101 (13 numerical)
-~k = -1101
Interpreting bits 1101 in 2’s complement form yeilds numerical vlaue is -(2^4 – 13) = -3. Applying ‘-’ on the result leaves 3.

Same analogy holds for decrement. These results hold only for 2’s complement form.

What will be the output of functions at the extremes of bit pattern? For example x = 0×80000000.

@Dheeraj: Thanks for inputs. We have added the suggested point.

“Using delete on a pointer to an object not allocated with new gives unpredictable results. You can, however, use delete on a pointer with the value 0. This provision means that, when new returns 0 on failure, deleting the result of a failed new operation is harmless. See The new and delete Operators for more information” Probably the 0 thing can be added to the fact.

For delete ptr2, delete is not made at all for the stack allocated data. The run time environment takes care of allocating and deallocating memory for stack frame data. So behavior is unpredictable for this also.

#include<stdio.h>
#include<stdlib.h>

int add1(int x)
{
   return -~-x;
}

int main()
{
  printf("%d", add1(11));
  getchar();
  return 0;
}

So if there are negative numbers, is the only difference that 1) we can skip neg numbers because they only decrease the sum; 2) for the pos number after a neg number, use the incl & excl of the last pos number, and incl of the current number can include the last pos number ’cause they are not adjacent.

This however, doesn’t change time O(n).

#include<stdio.h>

void foo()
{
   printf("foo called");
}

int main()
{
   foo();
   getchar();
   return 0;
}

would work fine since when foo() is called the compiler has already seen the foo() defined above.
However, the following will not work,

#include<stdio.h>

int main()
{
   foo();
   getchar();
   return 0;
}
void foo() /*Not OK since we do not have a prototype defined */
{
   printf("foo called");
}

In order for this to work, you insert a function prototype for foo() so that you can define it anywhere in the file and not necessarily before the point it is called. Hence, this would work fine:

#include<stdio.h>

void foo(void); /* function prototype */
int main()
{
   foo();
   getchar();
   return 0;
}
void foo() /* function is defined after the point it is called. It is OK since we have a function prototype. */
{
   printf("foo called");
}

int PivotedBinarySearch(arr, lo, high, num)
{
 int mid = (lo+hi)/2;

 if (arr[mid]==num)
    return mid;

 if (num < arr[mid])
 {
  /* Possible that elements on left may be normal  sorted or may be pivoted sorted. So num can be in any half */
  if (ar[lo] < arr[mid])
   {
    /* Normal Sorted */
    if (a[lo] < num)
     /* Num is in first half and is in between lo and
     mid */
     return binarysearch(arr, lo, mid-1, num);
    else
      PivotedBinarySearch(arr, mid+1, hi, num);
   }
  else // Pivoted sorted
   {
    if (num <a> a[mid])
{
 /* Similar checks as of earlier conditions */
 if (a[mid] < a[hi])
 { /* Normal sorted */
   if (num < a[hi])
    return binarysearch(arr, mid+1, hi, num);
   else
    /* num is in second pivoted half */
    PivotedBinarySearch(arr, lo, mid-1, num);
 }
 else
 { /* Pivoted search */
  if (a[lo] < num)
   return binarysearch(arr, lo, mid-1, num);
  else
   PivotedBinarySearch(arr, mid+1, hi, num);
 }
}
}

Please ignore all other comment and code posted, by bunty, on 5th Sep. Those have missed few conditions.

http://geeksforgeeks.org/forum/topic/please-explain-it