#coding everything

Pointers are generally the most feared part in a programming language. The only concept which many programmers doesnt seem to get. Well just get over the fact that pointers are somrthing terrifying build only to make prgrammers like us have horrifying nighmares....!! Heres the truth about pointers....!! POINTERS ARE NOTHING MORE THAN A VARIABLE...!! but the twist here is that they are a special kind of variables that stores special kind of info and that special info is the ADDRESS of another variable. See just like an int variable can store only int values and a float can store only float values, same is the case with the pointers. An int pointer stores the address of an integer variable only and not a float variable. So in 1 line a pointer is : SIMPLY A VRAIABLE THAT STORES ADDRESSES OF ANOTHER VARIABLE OF SAME DATA TYPE. DEFINING A POINTER defining a pointer is a little different than defining variables. int* x; /*we just declared an integer pointer which means that it vil only store addresses of integer variables.*/ dont be confused with the star (*)...u can also do lyk int *x or int * x...its all d same....!! Similarly to create a float or a char pointer just change the data type float* x; char* x; now store something in the pointer. REMEMBER : The variable that the pointer is pointing to is called a "POINTEE". int pointee; int* pointer; pointer = &pointee; //Now wat the hell is "&" for.. >:) this is known as "address of" operator it takes a variable and returns its address. for eg: &pointee will give you the address of pointee, remember that pointers only store addresses so if we want pointer to point to pointee we will give the address of pointee So pointer is pointing to pointee now so wat.....?? Now we can access pointee through a dereference operater(*)... int pointee = 10; int* pointer; like cout<<*pointer; vil give 10. Suppose address of pointee is 1000 and value is 10. So pointer vil store 1000 as its value and when *pointer is done, it will go to the address conatined by pointer which is 1000 as of now and vill access d value storesd at that address. So *pointer is now the same as pointee. doing *pointer = 20; or pointee = 20 //is the same thing Suppose there is another int pointer  int* another_pointer ; now we want this new pointer to point to the same location that pointer is pointing to. so we vil do lyk: another_pointer = pointer; //another pointer vil now also point to pointee; So now the final programme to illustrate the concepts: int main() { int pointee = 10; int *pointer1, *pointer2; //u cant do lyk int* pointer1,pointer2,here pointer2 vil be pointer1 = &pointee; //a simple int cout< cout<<*pointer1; //value of pointee i.e 10 pointer2 = pointer1; //pointer2 now points also points to pointee  *pointer2 = 20; //value of pointee chngd to 20 cout< cout< cout<<*pointer2; //value of pointee which is now 20 cout<<*pointer1; //value os pointee which is now 20 I hope this vil settle all the dust about baiscs of POINTERS and now we can start understandin the intricate details about pointers and their GOTCAHS....!! This is just a very breif intro to POINTERS and Theres still a lot to learn about pointers so keep writing code and experimenting....!!

What is a macro ? A macro is a piece of code that was labeled with a name. Whenever the preprocessor encounters it, the label is replaced by the associated code. Basically there are two kinds of macros : object-like macros (resemble data objects when used) and function-like macros (resemble function calls). Example for object-like macros: #include #define HELLO "Hello World Macro!" int main(){ printf(HELLO); return 0; } In the above example the label is HELLO and the associated data is “Hello World Macro!“ . Before compile-time the preprocessor will replace the label with the associated code. I think the results are pretty obvious. Example for function-like macros: #include #define MAX(a, b) ((a) > (b)) ? (a) : (b) int main(){ printf("%dn", MAX(1,3)); return 0; } In the case above MAX works exactly as a function that receives two arguments a, b and returns the maximum of the two . Note that the arguments are generic and appear to be typeless, the preprocessor is not performing any validation on types (that’s the compiler job) – this an advantage and also a disadvantage.

Continuing my post on INHERITANCE to INHERITANCE AND POLYMORPHISM Hope u guys hav read dat if not den plz read dat before reding dis....!! Inheritance is powerful but still u vil think dat v can do without it. Obviously yes .... v can, v have been doing without it coz v still use C language. But introucing d concept of POLYMORPHISM with inheritance takes d power to the next level. So remember INHERITANCE + POLYMORPHISM = VERY POWERFUL We introduce d concept of polymorphism by introducing VIRTUAL FUNCTIONS. So u should first understand d concept of Virtual functions. For eg: We create an ENEMY class and we have 20 different types of ENEMIES class enemy { public: void Attack(); } So dis becomes our base class for all enemies now if we have like 20 diff. enemies in our game and all of dem have different attacks. So without using Virtual functions we make 20 classes for diff enemies and all of dem inherit from base class enemy. den enemy obj = new badEnemy(); enemy obj1 = new BadAssEnemy(); enemy obj2 = new RealBadAssEnemy(); but when we call attack() of all three objects it will call d attack() of base class.....:( so bad na same kind of attack for every enemy makes ur game a dull game, UNTIL we make dat attack() function "VIRTUAL". Now each enemy class vil have different implementation for their attack() which vil actually make dem different. like badenemy attack() simply fires a pistol at you while BadAssEnemy's attack() fires a machine gun at you and RealBadAssEnemy's attack() fires rocket launcher at u..!! Hope ur following d point..it gives us d power to implement d function differently for every class.

INHERITANCE..... inheritance is a feature which allows us to easily create new class based on already created classes. By deriving from dem and adding more functionality. suppose we just finished creating our class for ENEMY which takes care of enemies animations, health and ai. we use dese enemies in d whole level and wen d ending of d level comes v hav to create a boss for d level. so instead of creating a new class boss we inherit d ENEMY class and add some more functionality because even the boss vil hv animations ,health and ai. So we dnt hv to write d code again for dese thngs. Inheritance is a very powerful tool but u shud use it wisely.... Rules wether to inherit or not. Rule 1. should be "Is a" relationship and not "Has a" relationship derived class should follow IS A model...like BOSS is an ENEMY so it can inherit enemy class. "has a" relationship should be followed when conatinment is to be applied. For eg: we have a class for weapons. So should weapon class inherit enemy class? NO..coz a weapon is not an enemy we can also hav a weapon. But an ENEMY has a WEAPON so it follows HAS A relationship. hence enemy class vil hav an object of WEAPON class inside it as its member. Rule 2. There should be beahvioral change and not only data change For eg: our boss class satisfies d 1st rule but suppose our boss is dumb and acts and looks xactly d same with only difference being its health. suppose normal enemy int health = 100; Boss health = 200; so dere is only chnge in data bt nt in d beahvior of boss so it fails d inheritance eligibility. But suppose our BOSS is very powerful and can also attack us from air where as normal enemy can only attack from land. Then there is also behavioral change.Then we should inherit d enemy class. while designing architectures inheritance shud be used carefully it can either simplify ur design or make ur nights sleepless. These are d 2 thumb rules that u shud always consider while deciding wether to inherit or not.

‎#include is a header file which enables us to pass multiple arguments to a function.You can pass multiple arguments by using "..." after d last variable. for eg: avg(int num,...); so this function avg(int num,...) vil take variable no of arguments and 1 integer arguments for num. it has 1 type : va_list to hold info abt variable arguments and 3 functions 1. va_start 2. va_arg 3. va_end va_start is used to start iterating by passing it 2 arguments : an object of type va_list and second parameter is d last named parameter of d function for eg: avg(int num,...) den va_list l; va_start(l,num); //dis initializes d list of variable arguments now to use individual arguments we use va_arg() it accepts va_list as first argument and type of d argument in the list. i.e va_arg(l,int); it returns d arguments in d same order in which dey were passed to the function...!! when we r done we use va_end to free d memory used by our list. In c it is mandatory to give 1 normal parameter but in c++ its nt mandatory....!!

WORKING OF VIRTUAL FUNCTIONS The address of all the functions are known at compile time with the exception of virtual functions. There address is not known at until run time, this is an example of late binding. One of d factors deciding the size of an executable (.exe) depends on this binding if a lot of early binding is done d size tends to increase and with late binding the size tends to decrease. In the world of VIRTUAL functions there are "VTABLES" and "VPTRS" VTABLES: They are an array of function pointers which holds the addresses of all the virtual functions. Only 1 VTABLE is generated for a single class VPTRS: It is a pointer which points at a location inside the VTABLE.Each object will have a VPTR which points to the correct location in a VTABLE. SO what happens when we call a virtual function 1.VPTR of that object is fetched 2.Offset in the VTABLE is calculated 3. At that offset is d function pointer which is pointing to the virtual function which is then fetched 4. finally the function call is made. Though the actual memory footprint of a virtual function is very complex but dis is d crux of what happens behind and should give u a basic understanding. NOTE: Compilers are smart enough to optimize VIRTUAL function calls. For eg: class A { virtual void func(); } class B : public A { virtual void func(); } int main() { A* obj = new B(): B* obj1 = new B(): obj.func(); \\Virtual function overhead, VTABLE lookup occurs here obj1.func(); \\No overhead here simple member function call passing a "this" pointer. return 0; }

Implicit this pointer Whenever we create a class There are data members and member functions... for eg: class A { int x; public: void display(); } A obj,obj1,obj2; Now each obj,obj1 and obj2 vil have there own local copy of x. But there vil be only 1 copy of Display() in memory not THREE copies. So how does the Display() know which objects'x X to show....?? This is solved by the compiler by implicitly passing a "this" pointer to display function. Read the next line carefully "A this pointer is a pointer which points to the calling object." so obj.display(); In this case it vil be of type A and it vil point to address of obj. so this call obj.display() will internally become A_display(&obj). So &obj gives display() function the address of the calling object i.e this pointe.So it knows which object to access. And REMEMBER this pointer is passed implicitly by the compiler i.e without the knowledge of the programmer. But now u knw...lol

Structure Padding: Whenever we create classes and structures we should pay special attention to the way we r defining variables insdie, because the size of the struct or class depends on it. Also frequently used variables shoild be kept on top in order to avoid cache misses. A class or a struct is always a multiple of the largest sized datatype inside it. for eg: struct A { double a; char ch; }; now sizeof(A) == 16 and not 8 + 1 = 9 even if the struct is rewritten like struct A { double a; char ch; char ch1; char ch2; char ch3; }; even then the size vil be 16 All variables defined inside a struct or a class are alligned in memory according to their size. Like an int can only be stored at addresses 4,8 and 12 that are multiples of 4. 6 is an invalid address for an int.Similarly for double it can be strored only at multiples of 8. NOTE: A char can be stored at any byte coz its nly of 1 byte. for eg: struct A { char ch; int x; char ch1; double d; }; 1 + 4 + 1 + 8 = 14 and considering double final size must be 16 but actually sizeof(A) == 24 .............WHY??? Now lets see WHY, hypothetical starting address 0; 0-1 1 byte for ch now next valid address for int is 4, hence 1-2 padding 2-3 padding 3-4 padding 4-8 4 bytes for int 8-9 1 byte for ch1 Now next valid address for double vil be 16, hence 9-16 7 bytes for padding 16-24 8 bytes for d So we wasted 10 bytes in padding dats actually a quite if you use dis struct for creating a 2D array of size 100*100 total objects of struct = 10000 bytes wasted on padding = 10000* 10 bytes Approx 98 kB is being wasted on just padding. Lets rearrange d structrure now struct A { double d; int x; char ch; char ch1; }; 0-8 8 bytes for double 8-12 4 bytes for int 12-13 1 byte for ch 13-14 1 byte for ch1 since d structure needs to be a multiple of 8 so final size would be 16 Only 2 bytes required for padding So for 100*100 array only 19kB is wasted on padding Simply shuffling d variables inside saved us 78kB So always keep this thing in mind while creating classes and structure in the future.