Solved Posts by vijayan121 Page 5

Remove Filter

void Example::function1( const Example& ex )
{
    // copy of the object on which function1 is called
    Example copy_of_this( *this ) ;

    /* whatever */

}
int main()
{
    Example doe;

    doe.function1(doe);
}
int main()
{
    Example doe;
    Example water(doe);

    doe.function1(water);
}
void Example::function1( const Example& ex )
{
    Example copy_of_ex( ex ) ;

    /* whatever */

}
class cIsBad : public [b]std::[/b]unary_function <T, bool> {
template< typename T, int T::*PM > struct A {} ;
struct B
{
    int i ;
    A< B, &B::i > a ;
};
#include <iostream>
#include <iterator>
#include <algorithm>

// iterator over a sequence using pointers to members 
// for next element and prev element
template< typename T, T* T::*NEXT, T* T::*PREV >
struct list_iterator : std::iterator<std::bidirectional_iterator_tag,T*>
{

    list_iterator( T* curr, T* last ) : current(curr), last_element(last) {}

    T*& operator* () { return current ; }

    list_iterator& operator++ ()
    { current = current->*NEXT ; return *this ; }

    list_iterator& operator-- ()
    { current = current ? current->*PREV : last_element ;  return *this ; }

    list_iterator operator++ …
// error: `undeclared_class' has not been declared
int undeclared_class::*pointer_to_member ; 

struct declared_class ;
// fine: `declared_class' has been declared
int declared_class::*pointer_to_member ;
#include <iostream>

template < typename T > struct list_base
{
    explicit inline list_base( T* a = 0, T* b = 0 ) 
        : member_a(a), member_b(b) {}

    T* member_a ;
    T* member_b ;
    // ...
};

template < typename T, T* list_base<T>::*PTR_MEMBER > 
struct list : list_base<T>
{
    explicit inline list( T* a = 0, T* b = 0 ) 
       : list_base<T>(a,b) {}

    inline T* get() { return this->*PTR_MEMBER ; }

    // ...
};

template < typename T, T* list_base<T>::*PTR_MEMBER >
inline T* get_it( list<T,PTR_MEMBER>& lst ) 
{ return lst.*PTR_MEMBER ; }

int main()
{
    int a = 11111, b = 22222 ;

    list<int,&list_base<int>::member_a> lst1( &a, &b ) ;
    list<int,&list_base<int>::member_b> lst2( &a, &b ) ;

    std::cout << *lst1.get() << '\t' << *get_it(lst1) << '\n' …
#include <iostream>

template < typename T > struct list
{
    explicit list( T* list::*pm, T* a = 0, T* b = 0 )
        : member_a(a), member_b(b), pointer_to_member(pm) {}

    T* get() { return this->*pointer_to_member ; }

    T* member_a ;
    T* member_b ;
    T* list::*pointer_to_member ;
    // ...
};

template < typename T > T* get_it( list<T>& lst )
{ return lst.*lst.pointer_to_member ; }

int main()
{
    int a = 11111, b = 22222 ;

    list<int> lst1( &list<int>::member_a, &a, &b ) ;
    list<int> lst2( &list<int>::member_b, &a, &b ) ;

    std::cout << *lst1.get() << '\t' << *get_it(lst1) << '\n'
              << *lst2.get() << '\t' << *get_it(lst2) << '\n' ;
}
template< typename T > struct list
{
    T* current ;
};

template< typename T, T* T::*PTRMEMBER >
T* get_next( list<T>& lst ) 
{ 
    lst.current = lst.current->*PTRMEMBER ; 
    return lst.current ;
}

struct A
{
    A* member_one ;
    A* member_two ;
};

int main()
{
    A one = A() ;
    A two = A() ;
    A three = { &two, &one } ;
    A four = { &three, &two } ;

    list<A> lst = { &four };

    std::cout << get_next< A, &A::member_one >( lst ) 
              << '\t' << &three << '\n' ;

    std::cout << get_next< A, &A::member_two >( lst ) 
              << '\t' << &one << '\n' ;
}
// Writes a string outStr to BIN file ofs
void stringToBINFile( const string& outStr, ostream& os )
{
    int n_chars = outStr.size() ; //Length has to be known when reading
    os.write((char *)&n_chars, sizeof(n_chars));
    if( n_chars > 0 ) os.write( (const char *)&*outStr.begin(), n_chars );
}

// Reads a string inStr from a BIN file ifs
void stringFromBINFile( string& inStr, istream& is )
{
    int n_chars;
    is.read((char *)&n_chars, sizeof(n_chars));
    if( n_chars > 0 )
    {
        inStr = string( n_chars, ' ' ) ;
        is.read( (char *)&*inStr.begin(), n_chars ) ;
    }
    else inStr = "" ;
}

void myWrite( const char* path, const string& outStr)
{
    ofstream ofs (path, ios::binary);
    stringToBINFile(outStr, ofs);
}

void myRead( const char* path, …
int main()
{

	base obj;
	//obj.baseInfo::SlotCount[0] = 5; // error

	base::baseInfo info_object ;
        info_object.SlotCount[0] = 5 ; // fine

}
void some_function( object …
std::wstring what2wstr( const std::exception& ex )
{
    // convert ex.what() to a wide character string and return it
    // trivially done here, ok for US-ASCII in UTF-8 => UNICODE
    std::string str( ex.what() ) ;
    std::wstring wstr( str.size(), ' ' ) ;
    std::copy( str.begin(), str.end(), wstr.begin() ) ;
    return wstr ;
}
struct wchar_exception
{
    virtual const wchar_t* wwhat() const { …
struct window
{
    // ...
    private:
       window( const window& ) ; // do not define this
       void operator= ( const window& ) ; // do not define this
    // ...
}
template <typename C>
typename C::iterator SlowFind(C& c, const typename C::value_type& v)
{
    typename C::iterator i;
    for (i = c.begin(); i != c.end() && *i != v; ++i)
        ;
    return i;
}
template < typename CNTR > struct container_traits
{  typedef typename CNTR::iterator iterator ;  } ;

template < typename CNTR > struct container_traits< const CNTR >
{ typedef typename CNTR::const_iterator iterator ; } ;

template < typename CNTR >
typename container_traits<CNTR>::iterator SlowFind( CNTR& cntr, 
                                const typename CNTR::value_type& value )
{   return std::find( cntr.begin(), cntr.end(), value )  ;  }
template < typename CNTR >
auto SlowFind( CNTR& cntr, const typename CNTR::value_type& value 
             ) -> decltype( cntr.begin() ) 
{   return std::find( cntr.begin(), cntr.end(), value )  ;  }
#include <iostream>

void foobar( int& arg )
{ std::cout << "foobar( int& )\n" ; }

void foobar( const int& arg )
{ std::cout << "foobar( const int& )\n" ; }

int main()
{
  int i = 7 ;

  foobar(i) ; // foobar( int& arg ) : exact match
  // foobar( const int& ) : conversion from int& to const int&
  // exact match preferred over conversion

  const int j = 7 ;
  foobar(j) ; // foobar( const int& arg ) : exact match
  // foobar( int& arg ) can't be called at all ( no conversion )

}
int main ()
{
  MyClass f(4);
  Func (f); // make copy of object f. f is a modifiable lvalue
  // overload resolves to exact match : MyClass::MyClass( MyClass& )

  const MyClass& g = f ;
  Func (g); // make copy of object g. g is not a modifiable lvalue
  // call MyClass::MyClass( const MyClass& ) to make the copy
}
#include <iostream>

struct A
{
  A() { std::cout << "A::default constructor\n" ; }
  A( const A& ) { std::cout << "A::copy constructor\n" ; }
  A& operator= ( const A& )
  { std::cout << "A::assignment\n" ; return *this ; }
};

struct B { A a[2] ; };

int main()
{
  B one ;
  std::cout << "-----------\n" ;
  B two(one) ;
  std::cout << "-----------\n" ;
  one = two ;
}
#include <stdexcept>

struct DataElement { /* ... */ };
struct AverageElement { /* ... */ };

#ifdef INHERIT

struct Chart // base class
{
  virtual void AddElement( const DataElement& ) = 0 ;
  virtual void AddElement( const AverageElement& ) = 0 ;
  // other (pure) virtual functions
};

struct DataChart : Chart
{
  virtual void AddElement( const DataElement& )
  { /* add DataElement */ }

  virtual void AddElement( const AverageElement& )
  { throw std::logic_error("incorrect element type") ; }

  // other overrides etc.
};

struct AveragesChart : Chart
{
  virtual void AddElement( const DataElement& )
  { throw std::logic_error("incorrect element type") ; }

  virtual void AddElement( const AverageElement& )
  { /* add AverageElement */ }

  // other overrides etc.
};

#else // GENERIC

template< typename T > struct chart_base
{
  // common stuff goes here
};

template< typename T > struct chart ; // generalization

// specialization
template<> struct chart<DataElement> : chart_base<DataElement> 
{
  void addelement( const DataElement& ) ;
  // other DataChart specific stuff
};

// specialization
template<> struct chart<AverageElement> : chart_base<AverageElement>
{
  void AddElement( const …
#include <vector>
#include <iostream>
#include <typeinfo>

template <class T>
class CObject
{
  public:
    typedef T numeric_type ;
    typedef std::vector<T>* output_type ;

    inline virtual ~CObject () { }
    virtual output_type Output( const std::vector<int>* Input ) = 0 ;
};

template< typename T >
typename T::output_type function( T& object,
                                  const std::vector<int>* input )
{
  typedef typename T::output_type result_type ;
  std::cout << "result type is " << typeid(result_type).name() << '\n' ;
  result_type result = object.Output( input ) ;
  return result ;
}
struct A
{
   char a ;
   int b ;
   char c …
struct align1
{
	double a;
	char b;
	int c;
	short d;
};
#include <iostream>
#include <limits>

// addition can be done using bitwise xor
// with adjustments for carry bits
unsigned int plus( unsigned int first, unsigned int second )
{
  unsigned int carry = first & second ; // the carry bits
  unsigned int result = first ^ second ; // the result bits

  while( carry ) // loop over the carry bits
  {
    carry <<= 1U ; // shift carry to next bit
    unsigned int temp = result ^ carry ;
    carry &= result ;
    result = temp ;
  }

  return result;
}

// to subtract, add the two's complement
unsigned int minus( unsigned int first, unsigned int second )
{
  unsigned int carry = ~second & 1U ;
  unsigned int twos_complement = ~second ^ 1U ;

  while( carry )
  {
    carry <<= 1U ;
    unsigned int temp = twos_complement ^ carry ;
    carry &= twos_complement ;
    twos_complement = temp;
  }

  return plus( first, twos_complement ) ;
}

int main()
{
  enum { RADIX = std::numeric_limits<unsigned int>::radix } ;
  struct check_it { char static_assert[ RADIX == 2 ? 1 : -1 ] ; } ;

  for( int i=0 ; i<10 ; ++i )
  {
    unsigned int a = std::rand()%1000 ;
    // a*7 === ( a*8 - a ) === ( a*4 + a*2 + a )
    std::cout << a << " * 7  = " << minus( a<<3U, a ) << " ("
       << plus( a<<2U, plus( a<<1U, a ) ) << ") (" << a*7 << ")\n" ;
  }
}
template< typename T, typename A, template
          <typename VALUE_TYPE,typename ALLOCATOR_TYPE> class Container >
int my_func( std::map<T, Container<T,A> >& arg ) 
{
  typedef std::map< T, Container<T,A> > Map;
  typedef typename Map::iterator Iter;
  typedef typename Container<T,A>::iterator CIter;

  int count = 0;
  // ...
  return count;
}
std::size_t max = 0; // Number set by user at execution
// ...
long (*pBigArray)[100][100] = new long [max][100][100];
case 1 : float hipvalley(); // this is the Hip/Valley choice.
case '1' : hipvalley(); // this is the Hip/Valley choice.
#include <cstdlib>
#include <string>

inline char random_digit() { return '0' + std::rand() % 10 ; }

inline std::string random_pin( std::size_t ndigits )
{
  std::string pin ;
  for( std::size_t i = 0 ; i < ndigits ; ++i ) pin += random_digit() ;
  return pin ;
}
// ...
int Strength = 5 ;
int Intelligence = 2 ;
int Agility = 3 ;
int Defense = 3 ;
int Health = 10 ;
int Level = 1 ;

for(;;)
{
  char classChoice ;
  cin >> classChoice ;

  if( classChoice=='W' || classChoice=='w' )
  {
    break ;
  }
  else if( classChoice=='M' || classChoice=='m' )
  {
    Strength = 2 ;
    Intelligence = 5 ;
    Defense = 2 ;
    break;
  }
  else
  {
    cerr << "You did not enter a legal value.\n";
  }
}

Character player( Strength, Intelligence, Agility,
                  Defense, Health, Level ) ;
player.DisplayStats() ;
// ...
#include <vector>
#include <algorithm>
#include <functional>
#include <iterator>

template < typename T, typename A,
           template< typename U, typename V > class container >
container<T,A> operator* ( const T& n,
                           const container<T,A>& cntr )
{
  container<T,A> result ;
  std::transform( cntr.begin(), cntr.end(),
                  std::back_inserter(result),
                  std::bind1st( std::multiplies<T>(), n ) ) ;
  return result ;
}

template < typename T, typename A,
           template< typename U, typename V > class container >
inline container<T,A> operator* ( const container<T,A>& cntr,
                                  const T& n )
{ return n * cntr ; }

int main()
{
  std::vector<double> v1(10,3.4) ;
  std::vector<double> v2 = 3.6 * v1 ;
}
#include <iostream>
#include <typeinfo>

struct base_class
{
  virtual void virtual_foo() = 0 ; // pure

  void nonvirtual_bar() …
#define DO_SORT(varName, a, b, c, d) (*(varName)).sortValues(a, b, c, d)
//...
    MySort<char> *myCharSorter = new MySort<char>();
    DO_SORT(myCharSorter, charPt, 0, 5, sortFunction);
//...
#include <cstdlib>
#include <iostream>
using namespace std;

template<class T>
class MySort
{
      private:

      public:
             MySort(){};
             ~MySort(){};
             void sortValues( T* value, int start, int size,
                              void (*functocall)(T*, T*));
             //This method accepts a user-defined function and sorts the value.
             //The pointer is expected to have more than just one value, so it will be an array of some type.

              bool isSorted( const T* value, int start, int size)
              {
                   for(int i = start; i < size-1 ; i++)
                   {
                        if(value[i] > value[i + 1])
                           return false;
                   }

                   return true;
              };
};

template<class T>
void MySort<T>::sortValues( T* value, int start, int size,
                            void (*functocall)(T*, T*))
{
    if(start < size)
    {
       while(!isSorted(value, start, size))
       {
            for(int i = start; i < size-1 ; i++)
            {
               T *left = value+i, *right = value+i+1 ;
               (*functocall)((left), (right));
            }
       }
    }
    else
       std::cerr << "Start point cannot be greater than the size!" ;
}

template< typename T > void sortFunction( T* arg1, T* arg2 )
{
  if( *arg2 < *arg1 )
  {
    T temp = *arg1 …
for( int i=0 ; i<10 ; ++i )
    numb2[i] = i%2 == 0 ? (i/2)*5 : i ;
#include <stdio.h>

void swap( int rows, int cols, float (**after)[rows][cols] , 
           float (**before)[rows][cols] )
{
  float (*temp)[rows][cols] = *after ;
  *after = *before ;
  *before = temp ;
}

int main()
{
  int rows = 3, cols = 4 ;
  float one[rows][cols] ; one[0][0] = 1.1 ;
  float two[rows][cols] ; two[0][0] = 2.2 ;
  float (*p1)[rows][cols] = &one ; 
  float (*p2)[rows][cols] = &two ; 
  printf( "%f\t%f\n", (*p1)[0][0], (*p2)[0][0] ) ; 
  swap( rows, cols, &p1, &p2 ) ;
  printf( "%f\t%f\n", (*p1)[0][0], (*p2)[0][0] ) ; 
}
void array_function( int rows, int cols, float (*after)[rows][cols],
                     float (*before)[rows][cols] )
{
	//for some iterations	
	for(;;)
	{
		int i, j ;
		//for all the elements int the array
		for (i=1; i<rows; i++)
			for(j=1; j<cols; j++)
				(*after)[i][j] = 4 * (*before)[i][j] ;

		//afterwards prepare for the next iteration
		swap( rows, cols, &after, &before ) ;
	}
}
for(it = aMap.begin(); it != aMap.end(); it++){
  //some processing
  if(//some condition){
    //some processing
    aMap.erase(key);
    // this is undefined behaviour
    // the iterator is invalid after the erase
    it--;
  }
}
it = aMap.begin() ;
while(  it != aMap.end() )
{
  //some processing
  if(some_condition)
  {
    //some processing
    aMap.erase( it++ ); // postfix required
    continue; // don't increment again
  }
  ++it ; // not erased, increment
}