Mensajes

Para esta situación no era lo más adecuado, pero ya que todos ponían su código yo también quería xDDD

Esta bien para las situaciones en las cuales, no puedas saber cuantos numeros vas a guardar.

Otra forma de implementarlo sin vectores. Gracias a la magia de los punteros:

Código (c) [Seleccionar] Expandir

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

struct Eslabon
{
   int N;
   Eslabon* Anterior;
};
int main()
{
   Eslabon* Numero = (Eslabon*)malloc(sizeof(Eslabon));
   Eslabon* Buffer;

   int Cantidad;
   int Total = 0;

   Numero->Anterior = NULL;

   do
   {
       printf("Inserta numeros, introduce 0 para finalizar: ");
       scanf("%d",&Numero->N);

       if (Numero->N != 0)
       {
           Buffer = Numero;
           Numero = (Eslabon*)malloc(sizeof(Eslabon));
           Numero->Anterior = Buffer;
       }
   }while(Numero->N != 0);

   // Desliamos la cadena

   Cantidad = Numero->N;

   while (Numero->Anterior != NULL)
   {
       Numero = Numero-> Anterior;
       Cantidad += Numero->N;
       Total++;
   }

   printf("La media es %d ",Cantidad/Total);
   getchar();

return 0;
}

Yo optó por la división por categorías:

- Nivel.
- Personaje.
- Elementos.

Si alguno tiene elementos comunes, se hace una clase aparte "physics" y se hereda de ella.

Si esa clase a su vez, tiene elementos comunes con otras. Se hace otra clase y se hereda de ella también.

Una cosa muy importante en la arquitectura de un juego es el interpetre de niveles, generalmente yo le pasaba un mapa en una matriz char y este era capaz de interpetrar paredes, objetos, personajes... Esto facilita mucho el diseño, ya que cuando quieras añadir niveles nuevos. Solo tendrás que hacer el mapa y el programa hará el resto.

al hacerlo como el segundo código, no se crea ninguna variable local verdad?

Se crea un puntero.

Pero variables nada, se pasa la dirreción de la variable anterior.

El fallo es que la cadena no tiene el caracter nulo '\0' que indica el fin de cadena.

http://foro.elhacker.net/empty-t382560.0.html

Busca la proxima vez ^^

Voy a rescatar el código de un viejo proyecto:

Código (cpp) [Seleccionar] Expandir


// Esta funcion copia el contenido de un archivo a otro

void AMC::CopiarArchivos(ifstream &Lectura,ofstream &Escritura,unsigned long long Tamanyo_Archivo)
{
char* Cosa; // Buffer para leer
unsigned int Tamanyo_Lectura; // Variable que designa el tamaño de cada lectura
unsigned long long Contador = 0;  // Variable auxiliar, se utiliza para contabilizar el progueso obtenido y calcular un porcentaje
    unsigned short Porcentaje = 0; // Porcentaje actual
    unsigned long long Limite; // Valor auxiliar correspondiente al 1% del tamanyo del archivo. Se utiliza para saber cuando hay que aumentar el porcentaje en 1
    unsigned long long Offset = 0; // Variable que contiene la posicion del archivo actual

if (!Lectura)
throw Excepcion("ERROR AL COPIAR ARCHIVOS, ARCHIVO DE ORIGEN NO ENCONTRADO",ARCHIVO_NO_ENCONTRADO);

// Si el tamanyo del archivo es inferior al buffer máximo permitido. Se leera el archivo del tirón
         
    if (Tamanyo_Archivo < MAX_LECTURA)
            Tamanyo_Lectura = Tamanyo_Archivo;
    else
             Tamanyo_Lectura = MAX_LECTURA; // Si no, se dejará en el máximo valor

/* Asignamos la memoria al buffer, si no se puede satisfacer la operación se intentará asignar un buffer menor,
si el tamaño del buffer llega a 1. La propia función de asignar memoria lanza una excepción que termina el programa */

while (!AsignarMemoria(Cosa,Tamanyo_Lectura))
{
Tamanyo_Lectura /=2;
}

/* Decidimos si vamos a mostrar el porcentaje o no, para aumentar el rendimiento. Solo se mostrará
si su tamaño es superior a 100 MB */

    if (Tamanyo_Archivo >  104857600)
Limite = Tamanyo_Archivo/100;
    else
             Limite = 0; // Desactivado
             

while (Offset != Tamanyo_Archivo) // Mientras la posicion del archivo no llegue a su tamaño
          {
               // Leemos y escribimos
   
               Lectura.read(Cosa,Tamanyo_Lectura);
               Escritura.write(Cosa,Tamanyo_Lectura);
   
   Offset += Tamanyo_Lectura; // Aumentamos el progueso del archivo
               
   // Si el muestreo de porcentaje está activado...
   
               if (Limite != 0)
               {
   Contador += Tamanyo_Lectura; // Aumentamos el medidor
   
   if (Contador >= Limite) // Si el medidor supera el 1% del archivo
   {
  Porcentaje++; // Aumentamos el porcentaje
  cout<<Porcentaje<<"%"<<endl; // Lo mostramos por pantalla
  Contador = 0; // Reseteamos el medidor
   }
               }
               
   // Antes de repetir el bucle, comprobaremos si en la proxima lectura desbordaremos el archivo
   
               if ((Tamanyo_Archivo - Offset) < Tamanyo_Lectura)
               {
  // Si así es, hacemos una lectura con lo que nos quede del archivo
 
                  Lectura.read(Cosa,Tamanyo_Archivo - Offset);
                  Escritura.write(Cosa,Tamanyo_Archivo - Offset);
 
  // Situamos el indicador de posición al final del archivo
 
                  Offset = Tamanyo_Archivo;
               }
               
         }
         
      delete[] Cosa; //Borramos la memoria dinámica usada
}

/* Asigna el buffer de lectura, devuelve verdadero si tuvo exito.

Si no tuvo exito, devuelve falso por si se quiere modificar. Si no se puede modificar más, se lanza una excepción */

inline bool AMC::AsignarMemoria(char* &Cosa,unsigned int Lectura)
{
try
{
Cosa = new char[Lectura]; // Asignamos el buffer
return true; // Hemos conseguido asignar el buffer con exito
}
catch(...) // Si ocurrió alguna excepción
{
if (Lectura > 1) // Se devolverá "falso" para indicar que no se pudo asignar la memoria y asi dar una oportunidad para asignar un buffer menor
return false;
else // Si el tamaño del buffer no puede disminuir más, se lanza una excepción.
throw Excepcion("Error inesperado en la memoria",MEMORIA_NO_DISPONIBLE);
}
}


Para entender lo que significa orientado a objetos, antes debes saber programar.

Aún así no te rindas, aunque C++ esté orientado a objetos puede usarse perfectamente sin ellos (esto es debido a que conserva compatibilidad con C).

Desde una una funcion publica no se puede mostrar el valor de una variable privada

Falso, esta sentencia es totalmente válida:

Código (cpp) [Seleccionar] Expandir

class Ejemplo
{
private:
            int Variable;
public:
           int ObtenerVariable(){ return Variable;}
};

El problema es mucho más sutil que eso:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using std::cout;
using std::cin;

#include <string>
using std::string;
using std::getline;

#include "cabezal.h"

tunombrefuncion::tunombrefuncion(string nombre)
{
Establecernombre(nombre);
}
void tunombrefuncion::Establecernombre(string Enombre)
{
   if (Enombre.length() <= 25)
   {
      nombrepersona = Enombre;
   }
   else
   {
      Enombre.substr (0 , 25);
      nombrepersona = Enombre;
   }
}
string Darnombre()
{
  return nombrepersona;

Te falta una llave al final. Además tendrías que escribir string tunombrefuncion::DarNombre()

yo tampoco usaría un return 0 al final ya que igualmente sale

Bueno el estándar dice que el main debe devolver algo.

Por lo que no viene mal ponerlo (de hecho es recomendable).