Ir para o conteúdo
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

flashed

classe array

Mensagens Recomendadas

flashed

Boa noite,

Recementemente comecei a estudar c++ e tenho a seguinte dúvida:

Preciso de criar um trabalho que basicamente é um array bidimensional e depois tem coisas a andar dentro desse array.

O "problema" é que tenho de usar poo com header (*.h) e source (*.cpp).

Já fiz tantas modificações que a minha cabeça está a andar à roda e já nem sei o que escrevo, já mudei o código muitas vezes, acho que nem vale a pena mostar.

Alguém me pode dar um exemplo simples? uma ajudinha?

O trabalho tem uma sala que vai conter uma mesa, um gato e 2 avatares. Depois eles vão-se movendo (excepto a mesa) e devem evitar o choque. Eu gerei uma coisa, mas estática(não é o desejado), mais ou menos assim:

G***A

****a

*****

***M*

*****

queria passar o array por parametro, para ir atualizando.. por ex

*G**A

****a

*****

***M*

*****

**G*A

****a

*****

***M*

*****

Neste caso o gato está a andar...

Obrigado!

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
flashed

Boas, não pedi código, mas sim ajuda ou ideias... e claro que podiam colocar uma ou outra expressão ou linha de código (a titulo de exemplo).

Mas acho que já descobri e aqui vai o que consegui (mas depois tenho de mudar e criar o resto):

Matriz.h

c++ class Matriz{
public:
   Matriz();
   ~Matriz();
   void PosicaoInicial(char **matrix, int linhas, int colunas);
   void Imprime(char **matrix, int linhas, int colunas);
   void AvancaDireita(char **matrix, int linhas, int colunas);
private:
   int linhas;
   int colunas;
   char **matrix; 
};

Matriz.cpp

c++
Matriz::Matriz(){

}
Matriz::~Matriz(){

}
void Matriz::PosicaoInicial(char **matrix, int linhas, int colunas){
   for (int i = 0; i < linhas; i++) {
       for (int j = 0; j < colunas; j++) {
           if(i==0 && j==0){
               matrix[i][j]='G';
           }
           else{matrix[i][j]='*';}
       }
   }
}
void Matriz::Imprime(char **matrix, int linhas, int colunas){
   for (int i = 0; i < linhas; i++) {
       for (int j = 0; j < colunas; j++) {
          cout<<matrix[i][j];
       }
        cout<<"\n";
   }
}
void Matriz::AvancaDireita(char **matrix, int linhas, int colunas){
   int x,y;
    for (int i = 0; i < linhas; i++) {
       for (int j = 0; j < colunas; j++) {
           if(matrix[i][j]=='G'){
               matrix[i][j]='*'; 
               x=i;
               y=j+1;
           }else{}
       }
    }
   matrix[x][y]='G'; 

}

main.ccp

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

   char **matrix;
   int linhas=3;
   int colunas=3;
   matrix = new char*[linhas];
   for (int i = 0; i < linhas; i++) {
       matrix[i] = new char[colunas];
   }

   Matriz m;
   m.PosicaoInicial(matrix, linhas, colunas);
   m.Imprime(matrix, linhas, colunas);
   m.AvancaDireita(matrix, linhas, colunas);
   m.Imprime(matrix, linhas, colunas);

   return 0; 
}

Claro que pode e haverá outras formas mais simples de fazer isto... não sei... foi a que consegui...

Podem fazer as respetivas criticas.

Ps: Nem toda a gente quer do forúm um trabalho feito, no meu caso, só queria um exemplo simples... (só um desabafo, não levem a mal).

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

Ps: Nem toda a gente quer do forúm um trabalho feito, no meu caso, só queria um exemplo simples... (só um desabafo, não levem a mal).

o problema de apresentar um exemplo simples, é que ninguem tem o tempo para fazer o que te vou apresentar:

position.hpp

#pragma once

struct Position
{
   int x;
   int y;

   bool operator==(const Position& pos) const { return x == pos.x && y == pos.y; }
   bool operator!=(const Position& pos) const { return x != pos.x || y != pos.y; }
};

object.hpp

#pragma once

class Room;

class Object
{
protected:
   Object(const char symbol, const bool is_movable = false);

public:
   char getSymbol(void) const;
   bool isMovable(void) const;

   Room* getRoom(void) const;
   Object& setRoom(Room* room);

protected:
   char m_symbol;
   bool m_is_movable;

   Room* m_room;
};

object.cpp

#include "object.hpp"

Object::Object(const char symbol, const bool is_movable)
   : m_symbol(symbol), m_is_movable(is_movable), m_room(nullptr)
{

}

char Object::getSymbol(void) const
{
   return m_symbol;
}

bool Object::isMovable(void) const
{
   return m_is_movable;    
}

Room* Object::getRoom(void) const
{
   return m_room;
}

Object& Object::setRoom(Room* room)
{
   m_room = room;
   return *this;
}

table.hpp

#pragma once

#include "object.hpp"

class Table : public Object
{
private:
   static const char SYMBOL = 'M';

public:
   Table(const char symbol = Table::SYMBOL);
};

table.cpp

#include "table.hpp"

Table::Table(const char symbol)
   : Object(symbol)
{

}

cat.hpp

#pragma once

#include "object.hpp"

class Cat : public Object
{
private:
   static const char SYMBOL = 'G';

public:
   Cat(const char symbol = Cat::SYMBOL);
};

cat.cpp

#include "cat.hpp"

Cat::Cat(const char symbol)
   : Object(symbol, true)
{

}

avatar.hpp

#pragma once

#include "object.hpp"

class Avatar : public Object
{
private:
   static const char SYMBOL = 'A';

public:
   Avatar(const char symbol = Avatar::SYMBOL);
};

avatar.cpp

#include "avatar.hpp"

Avatar::Avatar(const char symbol)
   : Object(symbol, true)
{

}

room.hpp

#pragma once

#include <map>
#include <memory>
#include <string>

#include "position.hpp"
#include "object.hpp"

class Room
{
private:
   static const char MIN_WIDTH = 5;
   static const char MIN_HEIGHT = 5;

public:
   Room(const int width = 10, const int height = 10);

   int getWidth(void) const;
   int getHeight(void) const;

   Room& addObject(const std::string id, Object* object, const int x = 0, const int y = 0);
   Room& addObject(const std::string id, Object* object, const Position pos);
   Object* getObject(const std::string id) const;
   Object* getObjectAt(const int x, const int y) const;
   Object* getObjectAt(const Position pos) const;

   Room& moveObjectUp(const std::string id, const int length);
   Room& moveObjectDown(const std::string id, const int length);
   Room& moveObjectLeft(const std::string id, const int length);
   Room& moveObjectRight(const std::string id, const int length);

   const Room& print(void) const;

protected:
   typedef struct
   {
       Position pos;
       std::unique_ptr<Object> object;
   } Reg;

protected:
   int m_width;
   int m_height;
   std::map<std::string, Reg> m_regs;
};

room.cpp

#include <iostream>

#include "room.hpp"

Room::Room(const int width, const int height)
   : m_width(std::max((int) Room::MIN_WIDTH, width)), m_height(std::max((int) Room::MIN_HEIGHT, height))
{

}

int Room::getWidth(void) const
{
   return m_width;
}

int Room::getHeight(void) const
{
   return m_height;
}

Room& Room::addObject(const std::string id, Object* object, const int x, const int y)
{
   return addObject(id, object, {x, y});
}

Room& Room::addObject(const std::string id, Object* object, const Position pos)
{
   if (m_regs.find(id) != m_regs.end() || getObjectAt(pos) != nullptr)
   {
       return *this;
   }

   Position realpos{std::max(std::min((int) Room::MIN_WIDTH, pos.x), 0),
                    std::max(std::min((int) Room::MIN_HEIGHT, pos.y), 0)};

   m_regs.insert(std::pair<std::string, Reg>{id, Reg{realpos, std::unique_ptr<Object>{object}}});
   object->setRoom(this);

   return *this;    
}

Object* Room::getObject(const std::string id) const
{
   auto reg = m_regs.find(id);
   if (reg == m_regs.end())
       return nullptr;
   return reg->second.object.get();
}

Object* Room::getObjectAt(const int x, const int y) const
{
   return getObjectAt({x, y});
}

Object* Room::getObjectAt(const Position pos) const
{
   for (auto reg = m_regs.begin(), end = m_regs.end(); reg != end; reg++)
   {
       if (reg->second.pos == pos)
           return reg->second.object.get();
   }

   return nullptr;
}

Room& Room::moveObjectUp(const std::string id, const int length)
{
   auto reg = m_regs.find(id);
   if (reg == m_regs.end() || !reg->second.object->isMovable())
   {
       return *this;
   }

   int steps = length;
   while (steps > 0)
   {
       if (reg->second.pos.y <= 0 || getObjectAt(reg->second.pos.x, reg->second.pos.y - 1))
       {
           return *this;
       }
       reg->second.pos.y -= 1;

       steps--;
   }

   return *this;
}

Room& Room::moveObjectDown(const std::string id, const int length)
{
   auto reg = m_regs.find(id);
   if (reg == m_regs.end() || !reg->second.object->isMovable())
   {
       return *this;
   }

   int steps = length;
   while (steps > 0)
   {
       if (reg->second.pos.y >= m_height || getObjectAt(reg->second.pos.x, reg->second.pos.y + 1))
       {
           return *this;
       }
       reg->second.pos.y += 1;

       steps--;
   }

   return *this;
}

Room& Room::moveObjectLeft(const std::string id, const int length)
{
   auto reg = m_regs.find(id);
   if (reg == m_regs.end() || !reg->second.object->isMovable())
   {
       return *this;
   }

   int steps = length;
   while (steps > 0)
   {
       if (reg->second.pos.x <= 0 || getObjectAt(reg->second.pos.x - 1, reg->second.pos.y))
       {
           return *this;
       }
       reg->second.pos.x -= 1;

       steps--;
   }

   return *this;
}

Room& Room::moveObjectRight(const std::string id, const int length)
{
   auto reg = m_regs.find(id);
   if (reg == m_regs.end() || !reg->second.object->isMovable())
   {
       return *this;
   }

   int steps = length;
   while (steps > 0)
   {
       if (reg->second.pos.x >= m_width || getObjectAt(reg->second.pos.x + 1, reg->second.pos.y))
       {
           return *this;
       }
       reg->second.pos.x += 1;

       steps--;
   }

   return *this;
}

const Room& Room::print(void) const
{
   for (int y = 0; y < m_height; y++)
   {
       for (int x = 0; x < m_width; x++)
       {
           auto obj = getObjectAt(x, y);
           if (obj)
               std::cout << obj->getSymbol();
           else
               std::cout << '.';
       }
       std::cout << std::endl;
   }

   return *this;
}

main.cpp

#include <iostream>

#include "avatar.hpp"
#include "cat.hpp"
#include "room.hpp"
#include "table.hpp"

#define TABLE_ID "table"
#define CAT_ID "cat"
#define AVATAR1_ID "avatar1"
#define AVATAR1_SYMBOL 'A'
#define AVATAR2_ID "avatar2"
#define AVATAR2_SYMBOL 'a'

int main(int argc, char** argv)
{
   Room room{5, 5};
   room.addObject(TABLE_ID, new Table{}, 3, 3);
   room.addObject(CAT_ID, new Cat{}, 0, 0);
   room.addObject(AVATAR1_ID, new Avatar{AVATAR1_SYMBOL}, 3, 0);
   room.addObject(AVATAR2_ID, new Avatar{AVATAR2_SYMBOL}, 3, 1);

   room.print();
   std::cout << std::endl;

   room.moveObjectDown(AVATAR2_ID, 5);

   room.print();
   std::cout << std::endl;

   return 0;
}

como podes ver, isto é um exemplo muito simples, no entanto, a quantidade de código apresentada não é algo que se faça em 2 minutos.

da proxima vez, apresenta uma dúvida concreta

Editado por HappyHippyHippo

IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
flashed

Boa noite,

Antes de mais obrigado pela resposta, mas ainda estou muito verde e do que colaste percebo pouco. Se para ti é simples e fácil, para mim é quase tudo incompreensivel. Eu sei, eu sei, tenho de estudar muito.

Podes-me indicar um site, livro ou power point (what ever) onde posso aprender (com bons exemplos e simples) os ponteiros, arrays e listas. São as coisas que mais me fazem confusão.

Agradecido.

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora

×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.