Mensajes

Hola gracias por sus respuestas ya me ha quedado mas claro. Voy a intentar bajar a un nivel mas bajo para conocer los drivers y lo demás. Pero voy a utilizar las librerías ya existentes aunque siempre quiero conocer como funcionan por dentro ya que en la mayoría de los libros o tutoriales te dice que no se necesario pero yo creo que asi se aprende mucho mas ya que si no sabes como funcionan nunca aprenderás a crear tus propias librerías mas complejas.

En la librería estándar hay muchas cosas que puedes intentar implementar sin necesidad de meterte en el tema de hardware o APIS.

En C++ puedes intentar recrear las STL (vector,list,map...).

ya que si no sabes como funcionan nunca aprenderás a crear tus propias librerías mas complejas.

Pues te equivocas completamente, no hay ninguna necesidad de saber como se implementan las librerías estándares (sobre todo las que van vía hardware). Tan solo tienes que aprender que hacen y como funcionan.

Es un paradigma que se llama "encapsulamiento".

No veo el problema, el scanf te debería permitir hasta el número máximo del sistema.

3. Has pensado en hacer algún manual. Solo sobre C++ que abarque los temas clases funciones herencia y polimorfismo. Ya que creo que es lo que más nos cuesta a nosotros los mortales  xD. Y para serte sincero las explicaciones me quedan muy claras.

http://www.minidosis.org/#/

La forma más natural es el multithreading.

El proceso de compilación se realiza archivo a archivo. En cada iteración, se explotan todos y cada uno de los includes que aparezcan en los archivos y eso conlleva una carga adicional.

Un ejemplo (presupongo que los includes están fuera de los ifdef para simplificar el ejemplo):

a.h:

Código (cpp) [Seleccionar] Expandir

#include <string>

b.h:

Código (cpp) [Seleccionar] Expandir

#include <string>
#include "a.h"

c.h:

Código (cpp) [Seleccionar] Expandir

#include<string>
include "a.h"
#incldue "b.h"

c.cpp

Código (cpp) [Seleccionar] Expandir

#include "c.h"

En este caso, a la hora de compilar, c.cpp, se cargará lo siguiente:

* #include <string> : se carga 3 veces
* #include "a.h": se carga 2 veces
* #include "b.h": se carga 1 vez
* #include "c.h": se carga 1 vez.

Lo ideal sería que cada uno de estos archivo se cargase una sola vez. Si bien las protecciones con #ifdef o con #pragma once evitan que la declaración de una clase o método aparezca más de una vez el compilador tiene antes leer y procesar el archivo de cabecera con la consiguiente demora en el proceso de compilación.

Esto aplicado a aplicaciones reales que pueden tener de 10 a 20 includes por archivo de cabecera pues te puedes imaginar que el trabajo en vano que hace el compilador se incrementa de forma sustancial.

El código final va a ser igualmente válido... solo que llevará más tiempo conseguir el mismo resultado.

En aplicaciones pequeñas no se notará la diferencia... en casos extremos como es mi caso, después de una revisión a fondo en este tema conseguimos reducir la compilación en más de 20 minutos... y el ahorro en memoria también se notó bastante.

No si eso lo he entendido. Quitar el include y dejar la "forward declaration".

El problema es el siguiente:

Código (cpp) [Seleccionar] Expandir

class punto;

class Linea
{
   punto Punto[100];

   void Dibujar()
   {
       for (int i = 0; i < 100;i++)
       {
               Punto[i].Dibujar();
       }
   }

}

¿Como sabe el compilador que Punto tiene un método dibujar?

Bueno en C se complica un poco más el asunto al no poder usar contenedores STL. Pero tampoco mucho más.

El algoritmo ya lo tienes tú hecho realmente:

1º Leer los primeros 100 nombres.
2º Lo ordenas alfabeticamente.
3º ¿No quedan más nombres por leer? Terminado.
4º Lee el siguiente nombre.
5º ¿Va después del último nombre?. Si es así volvemos al paso 3.
6º Coges la posición donde debería ir, sobreescribes el nombre que estaba antes. Vuelves al paso 3.

El paso 6º puede ser un poco más complejo de ver, lo pongo con más detalle:

1º ¿Va antes del primer nombre? Devolvemos esa posicion y ya hemos terminado.
2º Recorremos el array desde 1 hasta 100.
3º ¿Va antes del nombre actual? Terminamos el bucle y devolvemos la posición actual.
4º En caso contrario volvemos al paso 2.


Todo esto puede sonar un poco complicado así leído, por eso te invito a que intentes ir escribiendo código ya. No te lo pienses mucho.

Yo guardaría todos los nombres, los ordeno y cojo los 100 primeros.

¿C o C++? En C++ eso se hace rápido con con una estructura map:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
#include <map>

using namespace std;

int main
{
    map<string,bool> Nombres;
    ifstream archivo("Nombre.txt");
    string aux;

    if (!archivo) throw "Archivo no encontrado...";
   
    while (archivo.good())
    {
         getline(archivo,aux);
         Nombres[aux] = true;
    }

    string Nombres[100];
    int i = 0;

    for (map<string,bool>::iterator it = Nombres.begin(); it != Nombres.end(); it++)
    {
         cout<<"Guardando: "<<it->first<<endl;
         Nombres[i++] = it->first;
    }
    return 0;
}

El problema esque el vector<song> tiene un tamaño inicial de cero. Como no redimensionas estas adcediendo a posiciones no reservadas, de modo que levanta una excepción.

Tienes que reservar memoria previamente, te dejo la documentación de la clase vector:
http://www.cplusplus.com/reference/vector/vector/

Por cierto en este for:

Código (cpp) [Seleccionar] Expandir

bool isSongInCollection(const Collection &collection, Song song){
 
  bool repetida=false;
  int i;
 
  for(i=0;i<collection.idNextSong;i++){
    if(song.title==collection.songs[i].title && collection.songs[i].artist==song.artist){
      repetida=true;
    }
  }
  return repetida;   
   
}

Si esta repetida no deberías terminar la función devolviendo true? No tiene sentido seguir buscando.

PD: Olvidate de los typedef, no son necesarios en C++:

Código (cpp) [Seleccionar] Expandir

struct Song
{
  int id; // El identificador de una nueva cancion debe ser igual a idNextSong
  string title;
  string artist;
  string album;
  string genre;
  string url;
};

Y C++ tiene mecanismos más efectivos para progamación orientada a objetos (las clases). Te recomiendo que te las mires, los mecanismos de encapsulamiento que usa te evitará muchos errores.

Saludos.

5. Acostúmbrate a usar Forward declarations.

No me queda muy claro que sea "util" en la práctica, lo digo porque el compilador se quejara si intentas adceder a un miembro de ella.

¿Para que quieres una clase si no puedes hacer nada con ella? A no ser que estes haciendo un contenedor... Pero para eso ya están los STL de C++.

No me queda muy claro...

que leerá máximo 39 caracteres de la entrada estándar.

Si, pero se quedará el resto de caracteres "esperando" en el buffer de entrada. Volverán a aparecer cuando pidas otro dato por teclado.

Una solución sería vaciarlo a mano después de utilizar fgets:

Código (cpp) [Seleccionar] Expandir

void LimpiarBuffer()
{
   int ch;

  while ((ch = getchar()) != '\n' && ch != EOF);

}