C++

#include <iostream>
ostream& myhex ( ostream &o )
{
o.setf ( ios::hex) ;
return o ;
}
int main( )
{
cout << endl << myhex << 2000 ;
return 0;
}

 2000

There are two ways in which we can refer to a name of class or function that is defined within a namespace: Using scope resolution operator through the using keyword. This is shown in following example:
                             namespace name1
                             {
                             class sample1
                             {
                             // code
                             } ;
                             }
                            namespace name2
                             {
                             class sample2
                             {
                             // code
                             } ;
                             }
                             using namespace name2 ;
                             void main( )
                             {
                             name1::sample1 s1 ;
                             sample2 s2 ;
                             }

Here, class sample1 is referred using the scope resolution operator.

                           sample operator + ( sample a, sample b = sample (2, 3.5f ) )
                           {
                           }
                            void main( )
                            {
                             sample s1, s2, s3 ;
                             s3 = s1 + ; // error
                             }

 
                             #include
                             class sample
                             {
                             static sample *ptr ;
                             private:
                             sample( )
                             {
                             }
                             public:
                             static sample* create( )
                             {
                             if ( ptr == NULL )
                             ptr = new sample ;
                             return ptr ;
                             }
                             } ;
                             sample *sample::ptr = NULL ;
                             void main( )
                             {
                             sample *a = sample::create( ) ;
                             sample *b = sample::create( ) ;
                             }

    #include<iostream>

                             class date
                             {
                             private :
                             int day ;
                             int month ;
                             int year ;
                             public :
                             date ( int d = 0, int m = 0, int y = 0 )
                             {
                             day = d ;
                             month = m ;
                             year = y ;
                             }

                             // copy constructor
                             date ( date &d )
                             {
                             day = d.day ;
                             month = d.month ;
                             year = d.year ;  
                             }

                             // an overloaded assignment operator
                             date operator = ( date d )
                             {
                             day = d.day ;
                             month = d.month ;
                             year = d.year ;
                             return d ;  
                             }
                             void display( )
                             {
                             cout << day << "/" << month << "/" << year ;
                             }
                             } ;

                             void main( )
                             {
                             date d1 ( 25, 9, 1979 ) ;
                             date d2 = d1 ;
                             date d3 ;
                             d3 = d2 ;
                             d3.display( ) ;
                             }

#include <iostream>

                             class base
                             {
                             protected :
                             int i ;
                             public :
                             base ( int ii = 0 )
                             {
                             i = ii ;
                             show( ) ;
                             }

                             virtual void show( )
                             {
                             cout << "base's show( )" << endl ;
                             }
                             } ;

                             class derived : public base
                             {
                             private :
                             int j ;
                             public :
                             derived ( int ii, int jj = 0 ) : base ( ii )
                             {
                             j = jj ;
                             show( ) ;
                             }
                             void show( )
                             {
                             cout << "derived's show( )" << endl ;
                             }
                             } ;
                               
                             void main( )
                             {
                             derived dobj ( 20, 5 ) ;
                             }

base's show( )
derived's show( )

#include<iostream>
     void main( )
     {
     int i = 65000 ;

     int *iptr = reinterpret_cast ( i ) ;
     cout << endl << iptr ;

     iptr++ ;
     cout << endl << iptr ;

     i = reinterpret_cast ( iptr ) ;
     cout << endl << i ;

     i++ ;
     cout << endl << i ;
     }

#include <stdexcept>
#include <iostream>
#include <vector>
#include <utility>
#include <unordered_map>
using namespace std;
class TwoSum
{
public:
  static pair<int, int> findTwoSum(const std::vector<int>& list, int sum)
  {
     unordered_map<int,int> s;
     for (size_t i = 0; i < list.size(); ++i)
     {
        auto j = s.find(sum - list[i]);
        if (j != s.end())
          return make_pair(i,j->second);
        s[list[i]] = i;
     }
     return make_pair(-1, -1);
  }
};
#ifndef RunTests
int main(int argc, const char* argv[])
{
  std::vector<int> list;
  list.push_back(3);
  list.push_back(1);
  list.push_back(5);
  list.push_back(7);
  list.push_back(5);
  list.push_back(9);
  pair<int, int> indices = TwoSum::findTwoSum(list, 12);
  cout << indices.first << '\n' << indices.second;
  return 0;
}
#endif

3
2

#include <iostream>
// M x N matrix
#define M 4
#define N 5
// Dynamically Allocate Memory for 2D Array in C++
int main()
{
// dynamically allocate memory of size M*N
int* A = new int[M * N];
// assign values to allocated memory
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
*(A + i*N + j) = rand() % 100;
// print the 2D array
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
std::cout << *(A + i*N + j) << " ";    // or (A + i*N)[j])
std::cout << std::endl;
}
// deallocate memory
delete[] A;
return 0;
}

#include <string>
#include <stdexcept>
#include <iostream>
using namespace std;
class Palindrome
{
public:
   static bool isPalindrome(const std::string& word)
   {
       static int i,j;
       static int count;
       while(word[count]!='\0')
           count++;
       cout<<"count is"<<count<<endl;
       i=0;
       j=count-1;
       while(i<j)
       {
           cout<<endl<<"word[i]"<<word[i]<<endl<<"word[j]"<<word[j]<<endl;
           if(tolower(word[i++])!=tolower(word[j--]))
           {
               cout<<endl<<word<<" is not a Palindrome"<<endl;
               return 0;
           }
       }
       cout<<endl<<word<<" is a palindrome"<<endl;
       count = i = i= 0;
       return 1;
   }
};
#ifndef RunTests
int main()
{
    std::cout << Palindrome::isPalindrome("Deleveled");
    std::cout << Palindrome::isPalindrome("Malayalam");
    std::cout << Palindrome::isPalindrome("Bab");
    std::cout << Palindrome::isPalindrome("Balam");
}
#endif

class Parent {
public:
 void sleep() {}
};
class Child: public Parent {
public:
 void gotoSchool(){}
};
int main( )
{
 Parent parent;
 Child child;
 // upcast - implicit type cast allowed
 Parent *pParent = &child;
 // downcast - explicit type case required
 Child *pChild =  (Child *) &parent;
 pParent -> sleep();
 pChild -> gotoSchool();
 return 0;
}

// CPP program to illustrate  
// Run Time Type Identification  
#include<iostream>
using namespace std;
class B { };
class D: public B {};
int main()
{
   B *b = new D;
   D *d = dynamic_cast<D*>(b);
   if(d != NULL)
       cout<<"works";
   else
       cout<<"cannot cast B* to D*";
   getchar();
   return 0;
}
//This is give a run time error: “cannot dynamic_cast 'b' (of type 'class B*') to type 'class D*' (source type is not polymorphic)”
//Adding a virtual function to the base class B makes it working.
// CPP program to illustrate  
// Run Time Type Identification  
#include<iostream>
using namespace std;
class B { virtual void fun() {} };
class D: public B { };
int main()
{
   B *b = new D;
   D *d = dynamic_cast<D*>(b);
   if(d != NULL)
       cout << "works";
   else
       cout << "cannot cast B* to D*";
   getchar();
   return 0;
}

#include <iostream.h>
#include <pthread.h>
struct arg_struct {
   int arg1;
   int arg2;
};
void *print_the_arguments(void *arguments)
{
   struct arg_struct *args = (struct arg_struct *)arguments;
   cout<< args -> arg1<<endl;
   cout<< args -> arg2<<endl;
   pthread_exit(NULL);
   return NULL;
}
int main()
{
   pthread_t some_thread;
   struct arg_struct args;
   args.arg1 = 5;
   args.arg2 = 7;
   if (pthread_create(&some_thread, NULL, &print_the_arguments, (void *)&args) != 0) {
       printf("Uh-oh!\n");
       return -1;
   }
   return pthread_join(some_thread, NULL); /* Wait until thread is finished */
}
   return pthread_join(some_thread, NULL); /* Wait until thread is finished */
}

// CPP program without virtual destructor 
// causing undefined behavior
#include<iostream>
using namespace std;
class base {
  public:
    base()     
    { cout<<"Constructing base \n"; }
    ~base()
    { cout<<"Destructing base \n"; }     
};
class derived: public base {
  public:
    derived()     
    { cout<<"Constructing derived \n"; }
    ~derived()
    { cout<<"Destructing derived \n"; }
};
int main(void)
{
  derived *d = new derived();  
  base *b = d;
  delete b;
  getchar();
  return 0;
}

#include <string.h>
#include <iostream>
#include <map>
#include <utility>
using namespace std;
int main()
{
  map<int, string> Employees;
  // 1) Assignment using array index notation
  Employees[5234] = "Mike C.";
  Employees[3374] = "Charlie M.";
  Employees[1923] = "David D.";
  Employees[7582] = "John A.";
  Employees[5328] = "Peter Q.";
 cout << "Employees[3374]=" << Employees[3374] << endl << endl;
 cout << "Map size: " << Employees.size() << endl;
 cout << endl << "Natural Order:" << endl;
 for( map<int,string>::iterator ii=Employees.begin(); ii!=Employees.end(); ++ii)
{
      cout << (*ii).first << ": " << (*ii).second << endl;
            }
  cout << endl << "Reverse Order:" << endl;
for( map<int,string>::reverse_iterator ii=Employees.rbegin(); ii!=Employees.rend(); ++ii)
{
      cout << (*ii).first << ": " << (*ii).second << endl;
}
}

Employees[3374]=Charlie M.
Map size: 5
Natural Order:
1923: David D.
3374: Charlie M.
5234: Mike C.
5328: Peter Q.
7582: John A.
Reverse Order:
7582: John A.
5328: Peter Q.
5234: Mike C.
3374: Charlie M.
1923: David D.

#include <iostream>
using namespace std;
// implementing the stack class
class Stack
{
   int top;
   public:
   int a[10];  //Maximum size of Stack
   Stack()
   {
       top = -1;
   }
   // declaring all the function
   void push(int x);
   int pop();
   bool isEmpty();
};
// function to insert data into stack
void Stack::push(int x)
{
   if(top >= 10)
   {
       cout << "Stack Overflow";
   }
   else
   {
       a[++top] = x;
       cout << endl<<  "Element Inserted into Stack"<< x ;
   }
}
// function to remove data from the top of the stack
int Stack::pop()
{
   if(top < 0)
   {
       cout << "Stack Underflow \n";
       return 0;
   }
   else
   {
       return (a[top--]);
   }
}
// function to check if stack is empty
bool Stack::isEmpty()
{
   if(top < 0)
   {
       return true;
   }
   else
   {
       return false;
   }
}
// implementing the queue class
class Queue {
   public:
   Stack S1, S2;
   //declaring enqueue method
   void enqueue(int x);
   //declaring dequeue method
   int dequeue();
};
// enqueue function
void Queue :: enqueue(int x)
{
   S1.push(x);
   cout << "Element Inserted into Queue "<< x << endl;
}
// dequeue function
int Queue :: dequeue()
{
   int x, y;
   while(!S1.isEmpty())
   {
       // take an element out of first stack
       x = S1.pop();
       // insert it into the second stack
       S2.push(x);
   }
   // removing the element
   y = S2.pop();
   // moving back the elements to the first stack
   while(!S2.isEmpty())
   {
       x = S2.pop();
       S1.push(x);
   }
   return y;
}
// main function
int main()
{
   Queue q;
   q.enqueue(10);
   q.enqueue(100);
   q.enqueue(1000);
   cout << endl<< "Removing element from queue" << q.dequeue();
   return 0;
}

Element Inserted into Stack10Element Inserted into Queue 10
Element Inserted into Stack100Element Inserted into Queue 100
Element Inserted into Stack1000Element Inserted into Queue 1000
Element Inserted into Stack1000
Element Inserted into Stack100
Element Inserted into Stack10
Element Inserted into Stack100
Element Inserted into Stack1000
Removing element from queue10

static int count=0;
class Message
{
public:
void put_message(void);
void get_message(void);
int message;
Message(void)
{
message=0;
cout<<"Objects Created"<<endl;
}
Message(int k)
{
message=k;
}
~Message() {
cout<<"Objects Destroyed"<<endl;
}
}q;
void Message::put_message(void)
{
message=12345;
}
void Message::get_message(void)
{
cout<<"The message is "<<message<<endl;
}
int main()
{
Message k(67890);
q.put_message();
q.get_message();
k.get_message();
return 0;
}

Objects Created
The message is 12345
The message is 67890
Objects Destroyed
Objects Destroyed