Mensajes

Nada más semejante a la realidad...

El artículo en la wikipedia enuncia:

No termino de entender qué tiene que ver con lo que he comentado yo entre C y C++.

C seguirá siendo la base de los sistemas operativos y la programación en general, ergo no creo que "muera" dentro de mucho, mucho tiempo...

Tampoco recuerdo haber comentado nada acerca de la muerte de ningún lenguaje :S:S:S

Los gurús de las predicciones son esa clase de personajillos especialistas en explicar los motivos por los que sus demoledoras previsiones no se han cumplido en absoluto.

Sinceramente no entiendo como se puede comparar la velocidad de ejecucion  de dos lenguajes de programacion.

Puede ser que un compilador de Rust genere codigo objeto mas optimizado que otro compilador de C.
Y aun así, mas optimizado y veloz para que plataforma?  Corre mas rapido en un pentium 3.. pero lo hará en un i5?

A ver, por defecto C tiende a ser más rápido que C++ y no depende en absoluto de las optimizaciones del compilador. Es más debido a las características del propio lenguaje. En C manejas la memoria a un nivel muy bajo, mientras que en C++ una simple línea de código puede desembocar en una serie de llamadas en cascada demoledora (resevas de memoria, herencia, métodos virtuales, ... )

Como norma general yo creo que cuanto más bajo sea el nivel del lenguaje más rápido tiende a ser, digo como norma general porque bien es cierto que los compiladores de lenguajes de alto nivel pueden llegar a hacer maravillas... aún así estas maravillas tienen un límite.

Con una variable.

Código (cpp) [Seleccionar] Expandir


int digitoSecuenciaMasLarga = -1;

// ...

if ( longitud > longitud_maxima)
{
  longitud_maxima= longitud;
 
  if ( digitoSecuenciaMasLarga == -1 )
    digitoSecuenciaMasLarga = numero;
  else if ( digitoSecuenciaMasLarga != numero )
    ++contador_iguales;

  longitud = 0;
}

Desde mi punto de vista, "auto" no debe usarse indiscriminadamente, solo en aquellos casos en los que el código quede más claro (por ejemplo en el caso de iteradores... todos conocemos los iteradores y no hace falta decir... esto es un iterador). Sin embargo, si de un vistazo rápido no consigues adivinar el tipo al que va a equivaler "auto" entonces es mejor usar el nombrado tradicional. Eso sí, es mi punto de vista, no intento que nadie piense igual.

Por otro lado, no se si cplusplus tiene documentación dedicada de forma exclusiva a la palabra "auto", no obstante, si buscas en google puedes encontrar bastante documentación:

http://en.cppreference.com/w/cpp/language/auto

Un saludo.

Código (cpp) [Seleccionar] Expandir

if ( longitud_maxima == 0 )
  printf( "Es una secuencia vacia.\n" );
else if ( contador_iguales>1 )
  printf("\nNo hay secuencia mas larga \"estrictamente\".\n");
else
  printf("\nLa subsecuencia mas larga tiene %d numeros (%d).\n\n", longitud_maxima, /*numero de la subsecuencia mas larga*/);

No hace falta ese if. Eso lo puedes comprobar al final:

* Si la longitud máxima es 0, es que no se ha introducido ninguna secuencia
* En caso contrario, puede suceder que haya una o varias secuencias máximas del mismo tipo ( 0 o 1 )
* O, caso final, hay una o varias secuencias máximas y éstas son de ambos tipos ( 0 y 1 )

Como ves, puedes eliminar ese if y mover su mensaje al final del programa.

Lo cierto es que, pensando un poco más, no hace falta usar "max":

Código (cpp) [Seleccionar] Expandir

vector<double>::iterator maximo(vector<double>& v)
{
  auto it = v.begin( );
  auto to_return = it;

  for ( ++it ; it != v.end( ); ++it )
  {
    if ( *it > *to_return )
      to_return = it;
  }

  return to_return;
}

* Si suponemos que se introduce una secuencia correcta, el primer if sobra
* Puedes reutilizar variables si su función es la misma
* Tienes que almacenar en algún sitio el carácter de la secuencia más larga
* La variable que almacena el carácter actual puede ser perfectamente un char
* scanf no te va a devolver EOF si el usuario pulsa "ENTER" ¿Has probado tu programa?

Algo así:

Código (cpp) [Seleccionar] Expandir

vector<double>::iterator maximo(vector<double>& v)
{
 vector<double>::iterator it;
 vector<double>::iterator to_return = v.begin( );

 double max = numeric_limits<double>::min( );

 for ( it = v.begin( ) ; it != v.end( ); ++it )
 {
   if ( *it > max )
   {
     to_return = it;
     max = *it;
   }
 }

 return to_return;
}

O, usando C++11

Código (cpp) [Seleccionar] Expandir

vector<double>::iterator maximo(vector<double>& v)
{
 auto to_return = v.begin( );

 double max = numeric_limits<double>::min( );

 for ( it = v.begin( ) ; it != v.end( ); ++it )
 {
   if ( *it > max )
   {
     to_return = it;
     max = *it;
   }
 }

 return to_return;
}



V2.0:

Código (cpp) [Seleccionar] Expandir

vector<double>::iterator maximo(vector<double>& v)
{
   return std::max_element( v.begin( ), v.end( ) );
}

Vale que con esta última versión no vas a practicar demasiado con los iteradores... pero nunca hay que perder de vista que la stl tiene infinidad de herramientas que hacen que no tengamos que reinventar la rueda cada dos por tres.

Un saludo.

Deberías revisar la implementación del operador de asignación (=) de tu clase "Asociacion". Este operador se llama al hacer la asignación "*as=consecuentes[1]".

Por otro lado, as=&consecuentes[0]; esto no va a tener ningún efecto porque "as" está declarada a nivel local, luego si haces que "as" apunte a otro objeto, ese cambio se va a perder fuera de la función:

Código (c) [Seleccionar] Expandir


void func( int* ptr )
{
*ptr = 200;
  ptr = 100;
}

int main( )
{
  int dato;
  int* ptr = &dato;

  func( ptr );

  printf( "%d\n", *ptr ); // imprime 200, ok
  printf( "%p\n, ptr ); // Va a ser distinto de 100, este cambio no se ha aplicado
}