class ScrollBar
{
  public:
 
    ScrollBar( int max )
      : _max( max ),
        _position( 0 )
   { }
 
    void Slide( int value )
    {
      _position += value;
 
      _position = std::max( _position, 0 );
      _position = std::min( _position, _max );
    }
 
    void SlideUp( )
    { Slide( -5 ); }
 
    void SlideDown( )
    { Slide( +5 ); }
 
    int Position( ) const
    { return _position; }
 
  private:
 
    int _position;
    int _max;
};

class ViewPort
{
  public:
 
    ViewPort( int x, int y, int width, int height )
      : _x( x ), _y( y ), _width( width ), _height( height )
   { }
 
    int X( ) const
    { return _x; }
 
    int Y( ) const
    { return _y; }
 
    int Width( ) const
    { return _width; }
 
    int Height( ) const
    { return _height; }
 
    int Left( ) const
    { return _x; }
 
    int Right( ) const
    { return _x + _width; }
 
    int Top( ) const
    { return _y; }
 
    int Bottom( ) const
    { return _y + _height; }
 
     void MoveTo( int x, int y )
    {
      _x = x;
      _y = y;
    }
 
  private:
 
    int _x;
    int _y;
    int _width;
    int _height;
};

int main( )
{
  ScrollBar scroll( 0, 20 );
 
  ViewPort viewPort( 0, 0, 800, 600 );
 
  std::cout << "Desplazamiento hacia abajo:" <<  std::endl;
  for ( int i = 0; i < 5; i++ )
  {
    scroll.SlideDown( );
    viewPort.MoveTo( 0, scroll.Position( ) );
    std::cout << "Posición: x=" << viewPort.X( ) << " y=" << viewPort.Y( ) << std::endl;
  }
 
  std::cout << std::endl;
  std::cout << "Desplazamiendo hacia arriba: " << std::endl;
  for ( int i = 0; i < 5; i++ )
  {
    scroll.SlideUp( );
    viewPort.MoveTo( 0, scroll.Position( ) );
    std::cout << "Posición: x=" << viewPort.X( ) << " y=" << viewPort.Y( ) << std::endl;
  }
}

int main( int argc, char** argv )
{
  // Tu codigo aqui
}

class Monomio
{
  public:
 
    Monomio( double multiplicador, double exponente )
      : _multiplicador( multiplicador),
        _exponente( exponente )
    {
    }
 
    double operator( )( double x) const
    {
      return pow( x * multiplicador, _exponente );
    }
 
    friend std::ostream& operator << ( std::ostream& out, const Monomio& monomio )
    {
      if ( monomio.multiplicador > 0 )
        out << "+";
 
      out << monomio.multiplicador;
 
      if ( monomio._exponente != 0.0 )
      {
        out << "x";
        if ( monomio._exponente != 1.0 )
          out << "^" << monomio._exponente;
      }
 
      return out;
    }
 
  private:
 
    double multiplicador;
    double _exponente;
};

class Polinomio
{
  public:
 
    Polinomio( const std::vector< Monomio >& monomios )
      : _monomios( monomios )
    { }
 
    double operator( )( double x) const
    {
      double resultado = 0.0f;
 
      for ( const auto& monomio : _monomios )
      {
        resultado += monomio( x);
      }
 
      return resultado;
    }
 
    friend std::ostream& operator<<( std::ostream& out, const Polinomio& poli )
    {
      out << "y=";
 
      for ( const auto& monomio : poli._monomios )
        out << monomio;
 
      return out;
    }
 
  private:
 
    std::vector< Monomio > _monomios;
};
 
int main()
{
  std::vector< Monomio > monomios { { 1.0, 2.0 }, { -14.0, 1.0 }, { 48.0, 0.0 } };
 
  Polinomio poli( monomios );
 
  std::cout << "Función: " << poli << std::endl;
  std::cout << "Resultados: " << std::endl;
  for ( double x = 0; x < 10; x++ )
  {
    std::cout << "x=" << x << " - y=" << poli( x ) << std::endl;
  }
}

c = *s++;

c = *s;
s++;

if (c == sc)
{
  s[-1] = '\0';
}

#include <iostream>
#include <chrono>
#include <math.h>
 
int DigitosV1( int numero )
{
  int digitos;
  for ( digitos = 0; numero > 0; digitos++, numero /= 10 ) ;
  return digitos;
}
 
int DigitosV2( int numero )
{
  return log( numero ) + 1;
}
 
const int NUMERO = 1234567890;
const int MAXBUCLE = 1000000000;
 
int main( )
{
  int temp;
  std::chrono::time_point<std::chrono::system_clock> start, end;
  start = std::chrono::system_clock::now( );
  for ( int i=0; i < MAXBUCLE; i++ )
  {
    temp = DigitosV1( NUMERO );
  }
  end = std::chrono::system_clock::now();
 
  std::chrono::duration<double> elapsed_seconds = end-start;
 
  std::cout << "Tiempo division: " << elapsed_seconds.count() << "s\n";
 
  start = std::chrono::system_clock::now( );
  for ( int i=0; i < MAXBUCLE; i++ )
  {
    temp = DigitosV2( NUMERO );
  }
  end = std::chrono::system_clock::now();
 
  elapsed_seconds = end-start;
 
  std::cout << "Tiempo logaritmo: " << elapsed_seconds.count() << "s\n";
}
 

Tiempo division: 43.1613s
Tiempo logaritmo: 29.538s

Tiempo division: 19.1429s
Tiempo logaritmo: 29.564s

#include <iostream>
#include <chrono>
#include <limits>
#include <math.h>
 
const int INT5 = 12345;
const int INT7 = 1234567;
const int INT10 = 1234567890;
 
const double DOUBLE5 = 12345.0;
const double DOUBLE7 = 1234567.0;
const double DOUBLE10 = 1234567890.0;
 
template< class T >
int DigitosDIV( T numero )
{
  int digitos;
  T divisor = 10;
  T min = 1; // para que el bucle funcione con decimales
  for ( digitos = 0; numero >= min; digitos++, numero /= divisor ) ;
  return digitos;
}
 
template< class T >
int DigitosLOG( T numero )
{
  return log( numero ) + 1;
}
 
template< class T >
std::chrono::duration< double > Bucle( T numero, int(*func)(T) )
{
  int temp;
 
  auto start = std::chrono::system_clock::now( );
 
  const int max = std::numeric_limits< int >::max( );
  for ( int i=0; i < max; i++ )
  {
    temp = func( numero );
  }
  auto end = std::chrono::system_clock::now( );
 
  return end - start;
}
 
int main( )
{
  auto DivInt5  = Bucle( INT5,  DigitosDIV< int > );
  auto DivInt7  = Bucle( INT7,  DigitosDIV< int > );
  auto DivInt10 = Bucle( INT10, DigitosDIV< int > );
 
  auto LogInt5  = Bucle( INT5,  DigitosLOG< int > );
  auto LogInt7  = Bucle( INT7,  DigitosLOG< int > );
  auto LogInt10 = Bucle( INT10, DigitosLOG< int > );
 
  auto DivDouble5  = Bucle( DOUBLE5,  DigitosDIV< double > );
  auto DivDouble7  = Bucle( DOUBLE7,  DigitosDIV< double > );
  auto DivDouble10 = Bucle( DOUBLE10, DigitosDIV< double > );
 
  auto LogDouble5  = Bucle( DOUBLE5,  DigitosLOG< double > );
  auto LogDouble7  = Bucle( DOUBLE7,  DigitosLOG< double > );
  auto LogDouble10 = Bucle( DOUBLE10, DigitosLOG< double > );
 
  std::cout << "Tiempo division (int 5):     " << DivInt5.count( )     << " s\n";
  std::cout << "Tiempo division (int 7):     " << DivInt7.count( )     << " s\n";
  std::cout << "Tiempo division (int 10):    " << DivInt10.count( )    << " s\n\n";
  std::cout << "Tiempo log (int 5):          " << LogInt5.count( )     << " s\n";
  std::cout << "Tiempo log (int 7):          " << LogInt7.count( )     << " s\n";
  std::cout << "Tiempo log (int 10):         " << LogInt10.count( )    << " s\n\n";
  std::cout << "Tiempo division (double 5):  " << DivDouble5.count( )  << " s\n";
  std::cout << "Tiempo division (double 7):  " << DivDouble7.count( )  << " s\n";
  std::cout << "Tiempo division (double 10): " << DivDouble10.count( ) << " s\n\n";
  std::cout << "Tiempo log (double 5):       " << LogDouble5.count( )  << " s\n";
  std::cout << "Tiempo log (double 7):       " << LogDouble7.count( )  << " s\n";
  std::cout << "Tiempo log (double 10):      " << LogDouble10.count( ) << " s\n\n";
}

Tiempo division (int 5):     23.6144 s
Tiempo division (int 7):     33.9994 s
Tiempo division (int 10):    49.798 s
 
Tiempo log (int 5):          60.28 s
Tiempo log (int 7):          60.415 s
Tiempo log (int 10):         60.8651 s
 
Tiempo division (double 5):  81.3541 s
Tiempo division (double 7):  113.471 s
Tiempo division (double 10): 162.253 s
 
Tiempo log (double 5):       60.7651 s
Tiempo log (double 7):       60.8521 s
Tiempo log (double 10):      60.7481 s

void Binario::confirmarNumero(int numero)
{
    int decimal = 0;
 
    while (numero > 0)
    {
        int numeroSacado = numero & 0x01;
 
        decimal = decimal * 2 + numeroSacado;
 
        numero /= 10;
    }
    cout << "El equivalente decimal es: " << decimal << endl;
}

Pero no logo entender cual es el error ahora  

while ((numero / numero) != 0)

while ( numero != 0 )

while( numero > 0 )

while( numero >= 1 )

std::string cadena;
std::cout << "Introduce un número en binario" << std::endl;
std::cin >> cadena;
 
int numero = 0;
for ( unsigned int i = 0; i < cadena.length( ); i++ )
{
  numero *= 2;
  if ( cadena[ i ] == '1' )
    numero++;
}
 
std::cout << "El equivalente en decimal es: " << numero << std::endl;

char cadena[200];

void procesarMatriz( int matriz[10][20] );

char cadena[4];
strcpy( cadena, "abc" ); // Ok
 
printf( "%c %c %c", cadena[ 0 ], cadena[ 1 ], cadena[ 2 ] );

strcpy( cadena[4], "abc" );