Yo también voto por poner los atributos como privados, es más lo iba a publicar ahora. En  cuanto a lo de C++11 me parece una buena idea, así practicamos. Solo tengo el header de momento pero bueno, las funciones get ya están implementadas:

#ifndef UNITY_H
#define UNITY_H
#include <string>
 
class Unity
{
    public:
        Unity();
 
        void        setID                           (std::string newID);
        void        setGeneralType                  (std::string newType);
        void        setName                         (std::string newName);
        void        setNumberOfSoldiers             (int newNumberOfSoldiers);
        void        setInjuredSoldiers              (int newInjuredSoldiers);
        void        setMotivation                   (float newMotivation);
        void        setPhysicalState                (float newPhysicalState);
        void        setFavourableWeather            (std::string newFavourableWeather);
        void        setHarmfulWeather               (std::string newHarmfulWeather);
        void        setFavourableTerrain            (std::string newFavourableTerrain);
        void        setHarmfulTerrain               (std::string newHarmfulTerrain);
        void        setMeleeAttack                  (float newMeleeAttack);
        void        setMeleeDefense                 (float newMeleeDefense);
        void        setLongDistanceAttack           (float newLongDistanceAttack);
        void        setLongDistanceDefense          (float newLongDistanceDefense);
        void        setDiscipline                   (float newDiscipline);
        void        setSpeed                        (float newSpeed);
        void        setGeneralTypeFavourable        (std::string newGeneralTypeFavourable);
        void        setGeneralTypeHarmful           (std::string newGeneralTypeHarmful);
        void        setConcreteTypeFavourable       (std::string newConcreteTypeFavourable);
        void        setConcreteTypeHarmful          (std::string newConcreteTypeHarmful);
        void        setNutrition                    (float newNutrition);
        void        setResistence                   (float newResistence);
 
        std::string getID()                         const{return id;}
        std::string getGeneralType()                const{return generalType;}
        std::string getName()                       const{return name;}
        int         getNumberOfSoldiers()           const{return numberOfSoldiers;}
        int         getInjuredSoldiers()            const{return numberOfInjuredSoldiers;}
        float       getMotivation()                 const{return motivation;}
        float       getPhysicalState()              const{return physicalState;}
        std::string getFavourableWeather()          const{return favourableWeather;}
        std::string getHarmfulWeather()             const{return harmfulWeather;}
        std::string getFavourableTerrain()          const{return favourableTerrain;}
        std::string getHarmfulTerrain()             const{return harmfulTerrain;}
        float       getMeleeAttack()                const{return meleeAttack;}
        float       getMeleeDefense()               const{return meleeDefense;}
        float       getLongDistanceAttack()         const{return longDistanceAttack;}
        float       getLongDistanceDefense()        const{return longDistanceDefense;}
        float       getDiscipline()                 const{return discipline;}
        float       getSpeed()                      const{return speed;}
        std::string getGeneralTypeFavourable()      const{return generalTypeFavourable;}
        std::string getGeneralTypeHarmful()         const{return generalTypeHarmful;}
        std::string getConcreteTypeFavourable()     const{return concreteTypeFavourable;}
        std::string getConcreteTypeHarmful()        const{return concreteTypeHarmful;}
        float       getNutrition()                  const{return nutrition;}
        float       getResistence()                 const{return resistence;}
 
        virtual ~Unity();
 
    private:
 
        std::string id;
        std::string generalType;
        std::string name;
        int numberOfSoldiers;
        int numberOfInjuredSoldiers;
        float motivation;
        float physicalState;
        std::string favourableWeather;
        std::string harmfulWeather;
        std::string favourableTerrain;
        std::string harmfulTerrain;
        float meleeAttack;
        float meleeDefense;
        float longDistanceAttack;
        float longDistanceDefense;
        float discipline;
        float speed;
        std::string generalTypeFavourable;
        std::string generalTypeHarmful;
        std::string concreteTypeFavourable;
        std::string concreteTypeHarmful;
        float nutrition;
        float resistence;
};
 
 
#endif // UNITY_H

Hola, me parece un proyecto bastante interesante, no dudaría en colaborar. Para comunicarnos y organizarnos, voto por Google Docs para el proyecto y para hablar pues se crea un grupo en Google Groups y listo.

El simulador tendría que organizar la batalla con la táctica introducida por el usuario, mover las unidades y en cuanto éstas estén en el rango de alcance y en su turno, atacar. Estamos intentando crear una IA.

Bien, digamos que el desarrollo de este simulador podría ser el siguiente:

• 1. Mover ***¿según táctica?***.
• 2. Mirar el rango de alcance de cada una de las unidades y ver si hay enemigos.
• 3. Si está en el turno atacar.
• 4. Según las unidades, la fuerza del ataque, la defensa, la orografía del mapa y demás restar salud a ambas unidades únicamente si las dos están en su rango de alcance. Pongamos un ejemplo, si una unidad de arqueros ataca a una unidad de legionarios, los legionarios si no es cuerpo a cuerpo no provocan daño a los arqueros. Sin embargo si una unidad de caballería ataca a una de legionarios provocará más daño la de caballería, pero los legionarios también provocarán daño.
  

¡Un saludo!

Hola buenas otra vez, el problema era un bucle infinito en la función contar repes la otra función está perfecta, fíjate que en el segundo for de la funcion contar repes concretamente en este:

for(int j=0; j<contador; i++)
{
       if(i==array[j])
         {
             repes[i]++;
         }
}

Aumentas la variable i por lo cual la variable j siempre será menor que contador y creará un bucle infinito. Aquí está tu codigo arreglado(le he puesto un par de comentarios, leete sobre todo el de inicializar los valores a 0 en la funcion contar repes, quita esa parte del codigo y mira lo que pasa):

#include <iostream>
 
using namespace std;
 
const int numero = 100;
typedef int Valores[numero];
 
typedef int repeticion[numero];
 
 
 
void leerarray(Valores array, int& contador)
{
    /// Inicializa numero a 0, pues su contenido al principio podría ser -1 y no
    /// entraría al bucle.
    int numero = 0;
 
    do
    {
        cout<< "Introduzca el valor [" << contador << "] del vector \n";
        cin >> numero;
        array[contador] = numero;
        contador++;
    }while(numero != -1);
 
 
}
 
 
 
void contar_repes(Valores array,repeticion repes,int contador)
{
    ///Inicializa los valores a 0 para que no salgan números extraños
    ///al ser puestos por el compilador aleatoriamente.
    for(int i = 0; i < 10; i++)
        repes[i] = 0;
 
    for(int i = 0; i < 10; i++)
    {
        for(int j=0; j < contador; j++)
        {
            if(i == array[j])
            {
                repes[i]++;
            }
        }
 
    }
 
    for(int i = 0; i < 10; i++)
        cout <<" "<< i << ":" << repes[i] << " ";
 
 
}
 
int main()
{
    int contador=0;
 
    Valores array;
    repeticion repes;
 
 
 
    leerarray(array,contador);
 
    contar_repes(array,repes,contador);
 
    return 0;
}

¡Un saludo!  

Muchas gracias por el aporte y muy currado MeCraniDOS.

¡Un saludo!

A mí me funciona bien, ¿quizás pueda ser por el eclipse? , aquí tienes mi salida:

Hola buenas, suponiendo que EnteroAleatorio esté definido, el único problema es este:

Array ArrayCreaAleatorio(int linf, int lsup;)

Fíjate en el penúltimo carácter, eso no está bien, el punto y coma sobra, por lo que la línea quedaría:

Array ArrayCreaAleatorio(int linf, int lsup)

¡Un saludo!

Como ya me suponía no puedes hacer un include al archivo de fuente así que simplemente quita el:

#include "io.cpp"

Y vuelve a poner las definiciones de las funciones en el main.cpp. El cual queda así:

#include <iostream>
 
using namespace std;
 
int ReadNumber();
void WriteAnswer(int x);
 
int main()
{
 
    cout << "Give us your numbers!" << endl;
    int x = ReadNumber();
    int y = ReadNumber();
    WriteAnswer(x + y);
    return 0;
}

Y el io.cpp queda exactamente como estaba. Obviamente el compilador generará dos archivos objeto que luego enlazará.

¡Un saludo!

Vamos a ver, aunque esto va a en el subforo de C++ te respondo aquí, el error te dice que hay una definición múltiple de las funciones  ReadNumber() y WriteAnswer() ¿y porqué?  pues como podrás imaginar si en "io.cpp" ya están definidas esas funciones, y las defines otra vez en main.cpp hay una definición múltiple tal y como dice el compilador. Teóricamente deberías incluir un archivo de cabecera(.hpp) no uno de fuente(.cpp) pero como hasta tal punto no llego prefiero quedarme al margen. Para arreglarlo simplemente elimina las definiciones de las dos funciones del main.cpp aunque no es la mejor opción.

Siendo la forma de la ecuación:

ax² + bx + c = 0

Los datos de entrada serían a, b y c y después operas con ellos con la fórmula. No es complicado. Bueno no creo que me reprochen nada y digo que NO ES JUSTO dado que a otros usuarios les he podido decir lo mismo y no ofrecer el código, así que pido disculpas por eso, espero que darte este código no sea en vano.

#include <iostream>
#include <cmath>
 
 
int main(int argc, char *argv[])
{
    int a = 0;
    int b = 0;
    int c = 0;
 
    std::cout << "FORMA GENERAL DE LA ECUACION CUADRATICA : ax^2+-bx+-c = 0" << std::endl << std::endl;
    /** INTRODUCIMOS LOS DATOS **/
    std::cout << "Introduzca la variable a:" << std::endl;
    std::cin  >> a;
    std::cout << "Introduzca la variable b:" << std::endl;
    std::cin  >> b;
    std::cout << "Introduzca la variable c:" << std::endl;
    std::cin  >> c;
    /** Calculamos el interior de la raiz para comprobar si es negativo despues. **/
    int interiorRaiz = pow(b,2)-4*(a*c);
 
    int primeraSolucion = 0;
    int segundaSolucion = 0;
 
    /** Si es negativa no tiene solucion en los numeros reales
     *  solo en los numeros imaginarios.
     */
 
    if(interiorRaiz < 0)
    {
        std::cout << "Esta ecuacion no tiene solucion en los numeros reales." << endl;
    }
    else
    {
        primeraSolucion = (-b+sqrt(interiorRaiz))/(2*a);
        segundaSolucion = (-b-sqrt(interiorRaiz))/(2*a);
        if(primeraSolucion == segundaSolucion)
        {
            std::cout << "La unica solucion es:" << primeraSolucion;
        }
        else
        {
            std::cout << "La primera solucion es: " << primeraSolucion << std::endl;
            std::cout << "La segunda solucion es: " << segundaSolucion << std::endl;
            std::cout << std:: endl;
        }
    }
    std::cout << "Presione intro para terminar el programa ...";
    std::cin.ignore();
    std::cin.get();
 
    return 0;
}

EDITADO: Bueno me alegro, ¿ves como no era tan complicado?

Hola, ¿no llevas nada hecho? No sé si te has leído las normas del foro, pero no está permitido hacer tareas, solo prestar ayuda