Mensajes

[rir3760]

Hola, si pones cualquier cadena e imprimes rutatemp, te salen unos caracteres raros al principio:

Código [Seleccionar] Expandir

Escribe el nombre de archivo para abrirlo

hola
 H♦/home/miusuario/hola
Process returned 255 (0xFF)   execution time : 8.799 s
Press any key to continue., quizás eso al pasarselo a fopen o a alguna función es lo que te está fallando. ¿cómo lo arreglo? pues inicializando todo el arreglo a 0 con memset (o con la función strcopy que te indica el compañero rir3760 en el siguiente post al mío).

Código (cpp) [Seleccionar] Expandir

void * memset ( void * ptr, int value, size_t num );
Fill block of memory
Sets the first num bytes of the block of memory pointed by ptr to the specified value (interpreted as an unsigned char).

En concreto tienes que poner esto para inicializar esa zona de memoria en cero:

Código (cpp) [Seleccionar] Expandir

memset(rutatemp, 0, 51);
Otra forma de hacerlo sin usar memset es:

Código (cpp) [Seleccionar] Expandir

char rutatemp[201];     //La ruta completa del archivo
rutatemp[0] = '\0';



También deberías controlar la entrada con la funciones fgets + sscanf.

Además debes mirar si el archivo se ha abierto, si no te dará el segmentation fault. Con un simple if lo puedes comprobar:

Código (cpp) [Seleccionar] Expandir

archivo = fopen(rutatemp, "rt");
if(archivo)
   // Lo que quieras hacer con el archivo
else
   printf("Error al abrir el archivo");

Sé que no querías código pero la mejor manera es ejemplificando, la programación es aprender de los errores, si alguien te puede sacar de estos comederos de cabeza mejor.
Un saludo.

Bueno entonces si se usa std::string no es mejor usar std::stoi ( C++ 11 ).

Sin duda, no sabía de su existencia, gracias x64Core

Saludos 

La funciones que andas buscando es esta:

Código (cpp) [Seleccionar] Expandir

string std::to_string (int val);
string std::to_string (long val);
string std::to_string (long long val);
string std::to_string (unsigned val);
string std::to_string (unsigned long val);
string std::to_string (unsigned long long val);
string std::to_string (float val);
string std::to_string (double val);
string std::to_string (long double val);
Para convertir de int a string utiliza la función:

Código (cpp) [Seleccionar] Expandir

long int strtol (const char* str, char** endptr, int base);
Saludos.

[P Q R S]

Hola ShadowA7X, es un código muy limpio y la verdad bastante bueno. Te pongo un ejemplo práctico de lo que hace el algoritmo. Tenemos una lista con 4 nodos (o lista da igual como los llames):

P Q R S

Sabemos que esos nodos tienen un puntero al nodo siguiente, y esos estan tal que asi:

P -> Q , Q -> R , R -> S y S -> NULL

(entendiendo esa flechita por, "el nodo P tiene un puntero que apunta a Q")

Lo que hace esto es invertir el sentido, es decir, que P apunte a NULL, Q apunte a P , R apunte a Q y S apunte a R. (entendiendo por apuntar, que el nodo tiene un puntero que apunta a otro nodo). Realmente no modifica la lista en sí, sino a quienes apuntan sus nodos, el meollo del asunto está aqui:

Código (c) [Seleccionar] Expandir

next=aux->sgte;
aux->sgte=*inicio;

Saludos.

Hombre lo de poner nombre a las variables no se si se puede hacer, creo que no, lo que si puedes hacer es ir declarando punteros y reservando memoria y guardando esos punteros en un vector que luego eliminas, en ese caso es el segundo codigo que te he puesto. Tambien puedes hacer lo que te comenta Miky.

No entiendo bien tu pregunta, si ya tienes definidas las cadenas en una variable ¿para qué quieres otras? , o quieres decir esto:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>

int main(int argc, char *argv[])
{
   std::string sValores[3] = {"uno", "dos", "tres"};

   //Creamos las variables a partir de sValores
   std::string cadenaUno  = sValores[0];
   std::string cadenaDos  = sValores[1];
   std::string cadenaTres = sValores[2];

   // O a un array constante de caracteres.
   const char *cCadenaUno  = sValores[0].c_str();
   const char *cCadenaDos  = sValores[1].c_str();
   const char *cCadenaTres = sValores[2].c_str();

   std::cout << cadenaUno  << std::endl;
   std::cout << cadenaDos  << std::endl;
   std::cout << cadenaTres << std::endl;

   std::cout << cCadenaUno  << std::endl;
   std::cout << cCadenaDos  << std::endl;
   std::cout << cCadenaTres << std::endl;
   
   return EXIT_SUCCESS;
}
O quizás te refieras a esto:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>

using namespace std;

int main(int argc, char *argv[])
{
    string sValores[3] = {"uno", "dos", "tres"};
    vector<string*> variablesNuevas;
    //Creamos las variables a partir de sValores
    for(int i = 0; i!= sizeof(sValores)/sizeof(string); ++i)
    {
        string * tmp = new string(sValores[i]);
        variablesNuevas.push_back(tmp);
    }

    for(vector<string*>::iterator it = variablesNuevas.begin(); it != variablesNuevas.end(); ++it)
    {
        cout << **it << endl;
        // Liberamos memoria
        delete *it;
    }

    return EXIT_SUCCESS;
}

Crea una matriz con los coeficientes de las ecuaciones y ya aplicas gauss, resta las filas a lo bestia, aquí puedes multiplicar una fila por 253 si hace falta. De todas maneras despues de aplicar gauss puedes aplicar gauss-jordan y te da las soluciones del sistema.

Un saludo.

[EDITO: CORREGIDO GRACIAS crack81 por avisar.]

Poneis los códigos tan inentendibles que casi no puedo leerlos jajaja dejo el mío:

EDITO: CORREGIDO GRACIAS crack81 por avisar.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <math.h>

/**
*  \brief Función que calcula los primos que hay que sumar para llegar a un
*         numero.
*  \param number Numero al que hay que calcularle esos primos.
*/
void sumOfPrimes(uint64_t number);

/**
*  \brief Función que determina si un numero es primo o no lo es.
*  \param number Numero al que hay que determinarle su primalidad.
*  \return Esta función devolvera 1 si el numero es primo o 0 si no lo es.
*/
int  isPrime    (uint64_t number);

int main(int argc, char** argv)
{
    uint64_t number;
    printf("Introduzca un numero: ");
    scanf("%llu", &number);
    sumOfPrimes(number);
    return 0;
}


void sumOfPrimes(uint64_t number)
{
    // Si el numero es primo la suma ya esta hecha.
    if(isPrime(number))
        printf(" %llu", number);
    else
    {
        uint64_t sum = 0;           // Variable para albergar la suma que vamos
                                    // realizando.
        uint64_t iterator = number;  // Iterador de numeros primos.
        /* Si el iterador es par lo disminuimos en una unidad, porque un numero
         * par nunca va a ser primo y así ganamos eficiencia.
         */

        if(iterator%2 == 0)
                    --iterator;
        while(sum != number)
        {
            if(isPrime(iterator))
            {
                sum += iterator;
                printf(" %llu", iterator);
                iterator = number - sum;
                if(iterator%2 == 0)
                    --iterator;
            }
            /* Decrementamos iterator en dos porque un numero par no es primo y
             * por tanto no nos interesa.
             */
            else
                iterator -= 2;
        }
    }
}
int  isPrime    (uint64_t number)
{
    // El uno es primo.
    if(number == 1)
        return 1;
    // El dos es primo.
    if(number == 2)
        return 1;
    // Todos los numeros pares no son primos.
    if(number % 2 == 0)
        return 0;
    uint64_t sqr = (uint64_t) sqrt(number);

    /*  Si el numero que da la raiz es par, lo decrementamos en una unidad pues
     *  solo nos interesan los numeros impares, ya que un numero impar no es di
     *  visible por un numero par.
     */
    if(sqr % 2 == 0)
        --sqr;

    while (sqr > 1)
    {
        if( number % sqr == 0)
            return 0;
        sqr -= 2;
    }
    return 1;
}

[crack81]

Me alegra tu opinión y , efectivamente se puede mejorar pero tal como indicas, no es plan de hacerle la tarea con virguerias.   

Un fuerte saludo amigo crack81.

¡¡¡¡ Saluditos! ..... !!!!

Se puede afinar incluso un poquito más, descartando los impares del iterador. Pero no sé si poner el codigo, por lo de la tarea y eso..

Ah, pues ahora me ha entrado la curiosidad, cuál es el material que menos absorbe?

Creo que la cerámica.