[15 May] Predict the output

[1] 

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    char c = 'a';  
    // pass at compile time, may fail at run time
    int* q = (int*)&c; 
    int* p = static_cast<int*>(&c);
    return 0;
}
-----------------------------------------------------------------------------------------------------------------
#include <iostream>
using namespace std;
class Base {
};
class Derived : public Base {
};
int main()
{
    Derived d1;
    Base* b1 = (Base*)(&d1); // allowed
    Base* b2 = static_cast<Base*>(&d1);  
    return 0;
}
-----------------------------------------------------------------------------------------------------------------
#include <iostream>
using namespace std;
class Base {
    public:
    void func()
    {
        cout<<"Base::func called"<<endl;
    }
};
class Derived : public Base {    
};
int main()
{
    Derived d1;
    Base* b1 = (Base*)(&d1); // allowed
    Base* b2 = static_cast<Base*>(&d1); 
    b2->func();
    return 0;
}
-----------------------------------------------------------------------------------------------------------------
#include <iostream>
#include<array>
using namespace std;

class Base {
public:
    virtual void show(int i = 0) {
        cout << "Base::show() i = " << i << endl; 
    }
};

class Derived : public Base {
public:
    void show(int i = 20) {
        cout << "Derived::show() i = " << i << endl;
    }
};

int main() {
    Base *p = new Derived();
    p->show();
    delete p;
    return 0;
}
-----------------------------------------------------------------------------------------------------------------
#include <iostream>
#include<cstring>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base()" << endl;
        clear();
    }
    void clear() {
        memset(this, 0, sizeof(*this));
    }
    virtual void show() {
        cout << "Base::show()" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived()" << endl;
    }
    void show() {
        cout << "Derived::show()" << endl;
    }
};

int main() {
    Base *pb1 = new Base();
    pb1->show();
    delete pb1;
    return 0;
}
-----------------------------------------------------------------------------------------------------------------



-----------------------------------------------------------------------------------------------------------------



-----------------------------------------------------------------------------------------------------------------




-----------------------------------------------------------------------------------------------------------------




-----------------------------------------------------------------------------------------------------------------


-----------------------------------------------------------------------------------------------------------------

Comments

Post a Comment

Popular posts from this blog

Design Pattern and Architecture in C++

Image
 Design Pattern Singleton Pattern Factory Design Pattern Template Design Pattern Observer Design Pattern Observer code Example - easier one to refer Link Facade Design Pattern Command Pattern Object Pool design pattern Visitor pattern How to choose correct technology for your project ? What is Factory pattern ? It helps you to centralize the object creation process and by doing so it decouples concrete classes from your clients and you know with that you have a better architecture right now. Factory pattern uses inheritance for object creation. What is Abstract pattern ? Abstract pattern sits on the top of factory pattern and uses factory pattern to create objects. Abstract Factory patterns work around a super-factory which creates other factories. This factory is also called as factory of factories. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object. #include <iostream> using namespace std; class Butto...
Read more

Google Test (gtest) Notes

  A good unit test: Is able to be fully automated has full control over all the pieces running(Uses mocks or fakes to achieve this isolation when needed Can run in any order Runs fast Test a single logical concepts in system Is readable is maintainable Runs in memory(no DB or File access ) How to run it ? ccmake localmake /sdev/user/bin/run_ut Mock Objects Each unit test case test a single logical solution That is, test the behavior of a single function in a single scenario But many functions call other functions with their own complex behavior The complex behavior make it hard to test a single logical solution It is also difficult to get the called function to exhibit bad whether behavior So instead of calling the actual calling those other functions we call test doubles One particular kind of test double is mock What is Mock ? A Mock check that the double is called as expected It substitutes a behavior for the function that would be called EXPECT_CALL Mac...
Read more

Stack & Queue interview Questions

1. Implement stack using Queue. #include <iostream> #include<queue> using namespace std; class MyStack {   queue<int>Q;   public:   void push(int value)   {     int size = Q.size();     Q.push(value);     for(int i =0;i<size;i++)     {         Q.push(Q.front());         Q.pop();     }   }   void pop()   {       if (!Q.empty())       {           Q.pop();       }   }   bool empty()   {       return (Q.empty());   }   int top()   {       return (Q.front());   }   void printElement()   {       cout<<"Printing Queue Elements"<<endl;       queue<int>temp = Q;       while(!temp.empty())       {           c...
Read more