Mensajes

una variable booleana solo admite dos valores posibles, verdadero y falso.

La verdad es que no hay mucho más que explicar.

Has probado a utilizar el tipo de dato boolean ???

Código (java) [Seleccionar] Expandir


public class Person
{
  // ...
  boolean gender;

  // ...

  public void setGender( boolean newGender )
  {
    gender = newGender;
  }

  public boolean getGender( )
  {
    return gender;
  }
}

Código (cpp) [Seleccionar] Expandir


Persona Persona::*getHermano(){

    return hermano; // Me sale un triangulo con signode exclamacion (o admiracion)

}

Es así

Código (cpp) [Seleccionar] Expandir


Persona* Persona::getHermano(){

    return hermano;

}

Según la imagen, necesitas dos tipos de "nodos" diferentes... uno para el postre y otro para los ingredientes.

La diferencia básica es que el nodo de postres tiene que tener 2 punteros... uno para pasar al siguiente postre y otro para listar los ingredientes.

Con esto, yo eliminaría la clase nodo ya que no te va a aportar nada. Únicamente necesitas dos clases: Postre e Ingrediente.

Código (cpp) [Seleccionar] Expandir


class Ingrediente
{
  public:
    Ingrediente( const std::string nombre )
      : _nombre( nombre ),
        _siguiente_ingrediente( nullptr )
    {
    }

    const std::string& Nombre( ) const
    {
      return _nombre;
    }

    Ingrediente* SiguienteIngrediente( ) const
    {
      return _siguiente_ingrediente;
    }

    void SetSiguienteIngrediente( Ingrediente* ingrediente )
    {
      _siguiente_ingrediente = ingrediente;
    }

  private:
    std::string _nombre;
    Ingrediente* _siguiente_ingrediente;
};

class Postre
{
  public:
    Postre( const std::string& nombre )
      : _nombre( nombre ),
        _siguiente_postre( nullptr ),
        _primer_ingrediente( nullptr )
    { }

    ~Postre( )
    {
      Ingrediente* ingrediente = _primer_ingrediente;
      while ( ingrediente )
      {
        Ingrediente* para_borrar = ingrediente;
        ingrediente = ingrediente->SiguienteIngrediente( );
        delete para_borrar;
      }
    }

    const std::string& Nombre( ) const
    {
      return _nombre;
    }

    void SetSiguientePostre( Postre* siguiente_postre )
    {
      _siguiente_postre = siguiente_postre;
    }

    Postre* SiguientePostre( ) const
    {
      return _siguiente_postre;
    }

    Ingrediente* PrimerIngrediente( ) const
    {
      return _primer_ingrediente;
    }

    void NuevoIngrediente( const std::string& nombre )
    {
      Ingrediente* ingrediente_actual = _primer_ingrediente;
      while ( ingrediente_actual->SiguienteIngrediente( ) )
        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );

      ingrediente_actual->SetSiguienteIngrediente( new Ingrediente( nombre ) );
    }

    void EliminarIngrediente( const std::string& nombre )
    {
      Ingrediente* ingrediente_anterior = nullptr;
      Ingrediente* ingrediente_actual = _primer_ingrediente;
      while ( ingrediente_actual )
      {
        if ( ingrediente_actual->Nombre( ) == nombre )
        {
          if ( ingrediente_anterior )
            ingrediente_anterior->SetSiguiente( ingrediente_actual->Siguiente( ) );
          else
            _primer_ingrediente = ingrediente_actual->Siguiente( );
          delete ingrediente_actual;
          break;
        }           
        ingrediente_anterior = ingrediente_actual;
        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );
    }
 
  private:
    std::string _nombre;
    Postre* _siguiente_postre;
    Ingrediente* _primer_ingrediente;
};

Y luego, para rematar, puedes tener una tercera clase, una suerte de gestor de ingredientes para evitar código en el main:

Código (cpp) [Seleccionar] Expandir


class ListaIngredientes
{
  public:
    ListaIngredientes( )
      : _primer_postre( nullptr )
    {
    }

    ~ListaIngredientes( )
    {
      Postre* postre = _primer_postre;
      while ( postre)
      {
        Postre* para_borrar = postre;
        postre= postre->SiguientePostre( );
        delete para_borrar;
      }
    }

    Postre* NuevoPostre( const std::string& nombre )
    {
      Postre* postre = _primer_postre;
      while ( postre->SiguientePostre( ) )
        postre = postre->SiguientePostre( );

      postre->SetSiguientePostre( new Postre( nombre ) );
      return postre->SiguientePostre( );
    }

    Postre* BuscarPostre( const std::string& nombre ) const
    {
      Postre* postre = _primer_postre;
      while ( postre )
      {
        if ( postre->Nombre( ) == nombre )
          return postre;
      }

      return nullptr; // no hay postres con el nombre indicado
    }

    void BorrarPostre( const std::string& nombre )
    {
      Postre* postre_anterior = nullptr;
      Postre* postre = _primer_postre;
      while ( postre )
      {
        if ( postre->Nombre( ) == nombre )
        {
          if ( postre_anterior )
            postre_anterior->SetSiguientePostre( postre->SiguientePostre( ) );
          else
            _primer_postre = postre->SiguientePostre( );

          delete postre;
      }
    }

  private:
    Postre* _primer_postre;
};

Con esto creo que hacer el main para que cumpla con los requisitos es moco de pavo, no?? Incluso si te parece más limpio, puedes añadir los métodos para imprimir los ingredientes en la clase Postre... eso ya es a gusto de cada uno.

Y con respecto al uso de friend... úsalo con cuidado. La razón de encapsular el código es para que las clases sólo se puedan usar de una forma determinada... saltarse esa encapsulación no suele ser una buena idea. friend puede estar bien si diseñas algún tipo de API, para evitar, por ejemplo, que se puedan crear un objeto desde clases que no pertenezcan a dicha API... pero para prácticas de clase, salvo que estén específicamente pensadas para usar friend... no hacen falta.

Hazlo primero para números normales ( int ) y si eso ya luego te planteas hacerlo para números grandes.

No puedes hacer un delete de un objeto que no ha sido creado con new.

Código (cpp) [Seleccionar] Expandir

int main(int argc, char** argv) {

    Auto auto1;
    Auto auto2("Chevrolet","ASDF",300);
    Auto *auto3 = new Auto("Nissan","QWERT",500);

    // ...

    auto3 = &auto2;

    // ...
    auto3 = &auto1;

    // ...

    delete auto3;

    return 0;

}

el delete está afectando al objeto auto1, ya que has modificado el puntero de auto3 para que apunte a la instancia de auto1. auto1 no ha sido creado con new y, por tanto, no se puede eliminar con delete.

Además, para no dejar lagunas de memoria, deberías poner el delete antes de la línea "auto3 = &auto2;"

Código (cpp) [Seleccionar] Expandir


    delete auto3;
    auto3 = &auto2;

Una vez modificas el puntero "auto3" pierdes la referencia del objeto creado dinámicamente y, por tanto, desde ese momento es imposible eliminarlo y liberar esa parte de la memoria.

Los arrays heredados de c ( como la cadena de caracteres que comentas ) no son objetos en sí mismos. Esto quiere decir que no poseen propiedades ni métodos.

La única forma de conocer su tamaño es usar las funciones heredadas de C.

También puedes meter esa cadena en un string y preguntar al string por su tamaño.

Cuando se cifra un ejecutable realmente se está creando un programa nuevo que "encapsula" el ejecutable cifrado.

El nuevo programa no está cifrado... si no, no podría ejecutarse. Este nuevo programa dispone de las rutinas necesarias para ir descifrando el ejecutable original y que éste pueda funcionar. Una forma de hacer esto es mediante el uso de una máquina virtual ( al estilo de .net y java).

La secuencia para generar un salto de línea es algo dependiente del sistema operativo. Es decir, no es igual para Windows, Linux o Mac.

std::endl encapsula ese cambio y te proporciona la secuencia adecuada independientemente del sistema operativo sobre el que corra el programa.

\n pues te dará resultados diferentes e inesperados dependiendo de la plataforma sobre la que se ejecute tu programa.

Lo suyo sería con estructuras.

Diseña una estructura en la que puedas poner de forma ordenada toda la información de un pozo y luego, simplemente, creas tantas estructuras como pozos tengas.

Las estructuras las almacenas en un vector.

Obviamente los datos tienen que estar en cierto orden para que el archivo se pueda procesar de forma sencilla. Un ejemplo:

* Primero debería aparecer un número que representase el número de pozos.
* Después, filas de datos con la siguiente información:
1. Produccion del pozo
2. Valor de la produccion
* Las filas anteriores deberían ser, en tu caso, 28 por pozo e ir secuencialmente ( primero los datos del pozo 1, despues los del pozo 2, ... )

Estructuras del archivo hay miles, puedes hacer un archivo de texto plano como te de la gana o implementar diseños más complejos y estructurados( XML por ejemplo, aunque esto se saldrá del ámbito de tu práctica. )