Late/Dynamic Binding in C++

Late Binding using Function Pointers (C)

Locks in Multi-processing/multi-thread programming

DeadLock:
A deadlock is a situation wherein two or more competing actions are each waiting for the other to finish, and thus neither ever does.


LiveLock:

A livelock is similar to a deadlock, except that the states of the processes involved in the livelock constantly change with regard to one another, none progressing. Livelock is a special case of resource starvation; the general definition only states that a specific process is not progressing.

A real-world example of livelock occurs when two people meet in a narrow corridor, and each tries to be polite by moving aside to let the other pass, but they end up swaying from side to side without making any progress because they both repeatedly move the same way at the same time.

Livelock is a risk with some algorithms that detect and recover from deadlock. If more than one process takes action, the deadlock detection algorithm can repeatedly trigger. This can be avoided by ensuring that only one process (chosen randomly or by priority) takes action.

I2C protocol

http://www.i2cbus.com/theprotocol.html

new/delete operator

1. Return type of delete operator is void (not void*)




2. Exception and valid cases


char *p;

delete p; ==> exception (shown in picture)




Where as
char *p = 0;
delete p; .==> You can, however, use delete on a pointer with the value 0. This provision means that, when newreturns 0 on failure, deleting the result of a failed new operation is harmless.




2. Mixing both new/malloc and delete/free


class A {
public:
   A() { cout << "Constructor" << endl;
   ~A() { cout << "Destructor" << endl;
};


int main() {
  A *a = new A;
  free(a);                 ==> Calls only constructor; not destructor


 A *b = (A*)malloc(sizeof(A));
 delete b;               ==> Calls only destructor; not constructor


 A *c = new A;
 delete c;                ==> Calls both constructor and destructor
}