Thread: Static vector of shared_ptr

Originally Posted by nvoigt

Can you give a real world example for this? With real classnames so we can maybe suggest a better solution? Right now I don't even know what you are trying to do

Code:

#ifndef GRID_H_
#define GRID_H_

#include<vector>
#include<memory>
#include<random>
#include<ctime>

template <class T> class Grid{
	static std::vector<std::vector<std::shared_ptr<T>>> cell_grid;
public:
	Grid() {
		
	        cell_grid = std::vector<std::vector<std::shared_ptr<T>>> 
			(20, std::vector<std::shared_ptr<T>>(20, nullptr));
						
	}
	virtual ~Grid() {}

};

#endif

#ifndef BUG_H_
#define BUG_H_

#include "grid.h"
#include<memory>

class Bug : Grid<Bug>{
	int x_position, y_position;
public:
	Bug() : x_position(0), y_position(0) {}
	Bug(const int &x_pos, const int &y_pos){
		this->x_position = x_pos;
		this->y_position = y_pos;
	}
	~Bug() {}

	std::shared_ptr<Bug> factory(const Bug &object){

		return std::shared_ptr<Bug>(new Bug(object));
	}
};

#endif

#ifndef ANT_H_
#define ANT_H_

#include "grid.h"
#include<memory>

class Ant : Grid<Ant>{
	int x_position, y_position;
public:
	Ant() : x_position(0), y_position(0) {}
	Ant(const int &x_pos, const int &y_pos){
		this->x_position = x_pos;
		this->y_position = y_pos;
	}
	~Ant() {}

	std::shared_ptr<Ant> factory(const Ant &object){

		return std::shared_ptr<Ant>(new Ant(object));
	}
};

#endif

This is a real world example of what I would like to do. Grid is the base class, Bug and Ant are the derived classes. Presently, the only compiler problem relates directly and only to the static vector declaration which is what I am trying to solve.

I am open to class redesign according to best practices.

as I understand it, there will be one instance of cell_grid for each template type that is instantiated for that class. basically that means that Grid<Bug>::cell_grid is not the same object as Grid<Ant>::cell_grid. they will be distinct objects in memory.

Originally Posted by nvoigt

... Maybe you can step back a bit from all that design and patterns and tell us what you want to achieve. In plain english

Put smart pointers of (Doodle)Bug and an Ant on a Grid 2D vector that is shared between (Doodle)Bug and Ant.

I think the previous post has nailed it clearly although I am not certain why I want to define my 2D vector in main rather than in Grid.

Originally Posted by King Mir

A grid class could make sense. Just don't make it the same as Actor.

Thank you. I am still wrapping my mind around class design and have yet to read books on c++ related to good design. Grid won't be the same as Actor and it will not be a templated class either as generics are not needed here.

Thank you again for pulling my head out of the clouds.

Originally Posted by Imanuel

Thank you. I am still wrapping my mind around class design and have yet to read books on c++ related to good design. Grid won't be the same as Actor and it will not be a templated class either as generics are not needed here.

Thank you again for pulling my head out of the clouds.

I must simply be way out of my league to think I know c++ enough to program this simple project. I posted my code below and I appreciate being notified about my severe shortcomings and gaps in knowledge.

Code:

#include<cstdlib>
#include <memory>
#include "grid.h"

using namespace std;

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

	Bug bug(1, 3);
	Ant ant(1, 2);

	std::shared_ptr<Actor> pbug(new Bug(1, 3));
	std::shared_ptr<Actor> pant(new Ant(1, 2));

	Grid grid;

	grid.populate(pbug, 1, 3);
	grid.populate(pant, 1, 2);

	grid.move(pbug);

	return EXIT_SUCCESS;
}

#ifndef GRID_H_
#define GRID_H_

#include<vector>
#include<memory>
#include<random>
#include<ctime>
#include "bug.h"
#include "ant.h"

class Grid{

	std::vector<std::vector<std::shared_ptr<Actor>>> cell_grid;

	std::vector<std::pair<int, int>> *used_indices;

	bool move_north(std::shared_ptr<Actor> &object){
		// Move north
		if(object->get_y_position() - 1 >= 0 && 
			cell_grid[object->get_x_position()][object->get_y_position() - 1] == nullptr){
			north_helper(object);
			return true;
		}else if (typeid(Ant) == 
				typeid(cell_grid[object->get_x_position()][object->get_y_position() - 1])){
			cell_grid[object->get_x_position()][object->get_y_position() - 1].reset();
			north_helper(object);
			return true;
		}else{
			return false;
		}

	}

	void north_helper( std::shared_ptr<Actor> & object ) 
	{
		object->set_y_position(object->get_y_position() - 1);
		cell_grid[object->get_x_position()][object->get_y_position()] = object;
		cell_grid[object->get_x_position()][object->get_y_position() + 1].reset();
		cell_grid[object->get_x_position()][object->get_y_position() + 1] = nullptr;
	}

	bool move_east(std::shared_ptr<Actor> &object){
		// Move east
		if(object->get_x_position() + 1 <= 19 && 
			cell_grid[object->get_x_position() + 1][object->get_y_position()] == nullptr){
				east_helper(object);
				return true;
		}else if (typeid(Ant) == 
			typeid(cell_grid[object->get_x_position() + 1][object->get_y_position()])){
			cell_grid[object->get_x_position() + 1][object->get_y_position()].reset();
			east_helper(object);
			return true;
		}else{
			return false;
		}
	}
	void east_helper( std::shared_ptr<Actor> & object ) 
	{
		object->set_x_position(object->get_x_position() + 1);
		cell_grid[object->get_x_position()][object->get_y_position()] = object;
		cell_grid[object->get_x_position() - 1][object->get_y_position()] = nullptr;
	}

	bool move_south(std::shared_ptr<Actor> &object){
		// Move south
		if(object->get_y_position() + 1 <= 19 && 
			cell_grid[object->get_x_position()][object->get_y_position() + 1] == nullptr){
			south_helper(object);
			return true;
		}else if(typeid(Ant) == 
			typeid(cell_grid[object->get_x_position()][object->get_y_position() + 1] )) {
			cell_grid[object->get_x_position()][object->get_y_position() + 1].reset();
			south_helper(object);
			return true;
		}else{
			return false;
		}
	}

	void south_helper( std::shared_ptr<Actor> & object ) 
	{
		object->set_y_position(object->get_y_position() + 1);
		cell_grid[object->get_x_position()][object->get_y_position()] = object;
		cell_grid[object->get_x_position()][object->get_y_position() - 1] = nullptr;
	}

	

	bool move_west(std::shared_ptr<Actor> &object){
		// Move west
		if(object->get_x_position() - 1 >= 0 && 
			cell_grid[object->get_x_position() - 1][object->get_y_position()] == nullptr){
			west(object);
			return true;
		}else if(typeid(Ant) == 
			typeid(cell_grid[object->get_x_position() - 1][object->get_y_position()])){
			cell_grid[object->get_x_position() - 1][object->get_y_position()].reset();
			west(object);
			return true;
		}else{
			return false;
		}
	}

	void west( std::shared_ptr<Actor> & object ) 
	{
		object->set_x_position(object->get_x_position() - 1);
		cell_grid[object->get_x_position()][object->get_y_position()] = object;
		cell_grid[object->get_x_position() + 1][object->get_y_position()] = nullptr;
	}

	bool random_move_north(std::shared_ptr<Actor> &object){
		if(move_north(object)){
			return true;
		}else if (move_east(object)){
			return true;
		}else if(move_south(object)){
			return true;
		}else if (move_west(object)){
			return true;
		}else{
			return false;
		}
	}
	bool random_move_east(std::shared_ptr<Actor> &object){
		if(move_east(object)){
			return true;
		}else if (move_south(object)){
			return true;
		}else if(move_west(object)){
			return true;
		}else if (move_north(object)){
			return true;
		}else{
			return false;
		}

	}
	bool random_move_south(std::shared_ptr<Actor> &object){
		if(move_south(object)){
			return true;
		}else if (move_west(object)){
			return true;
		}else if(move_north(object)){
			return true;
		}else if (move_east(object)){
			return true;
		}else{
			return false;
		}
	}
	bool random_move_west(std::shared_ptr<Actor> &object){
		if(move_west(object)){
			return true;
		}else if (move_north(object)){
			return true;
		}else if(move_east(object)){
			return true;
		}else if (move_south(object)){
			return true;
		}else{
			return false;
		}
	}
public:
	Grid() {
		cell_grid = std::vector<std::vector<std::shared_ptr<Actor>>> 
						(20, std::vector<std::shared_ptr<Actor>>(20, nullptr));

		used_indices = new std::vector<std::pair<int, int>> (10);
	}
	virtual ~Grid() {}

	void populate(std::shared_ptr<Actor> &object, const int &x_pos, const int &y_pos){
		cell_grid[x_pos][y_pos] = object;
	}

	bool move(std::shared_ptr<Actor> &object){

		return random_move_north(object);
		/*
		srand((unsigned)time(NULL));
		default_random_engine engine(rand() % 1000);
		uniform_int_distribution<unsigned> distro(0, 3);

		switch(distro(engine)){
			case 0: return random_move_north(object);
			case 1: return random_move_east(object);
			case 2: return random_move_south(object);
			case 3: return random_move_west(object);
			default:
				return false;
		}
		*/
	}
};

#endif

#ifndef ACTOR_H_
#define ACTOR_H_

class Actor{
	int x_position, y_position;
public:
	virtual int get_y_position() const;

	virtual void set_y_position(int val);

	virtual int get_x_position() const;

	virtual void set_x_position(int val);
};

#endif

#include "actor.h"
#include<memory>

class Bug : public Actor{
	int x_position, y_position;
public:
	Bug() : x_position(0), y_position(0) {}
	Bug(const int &x_pos, const int &y_pos){
		this->x_position = x_pos;
		this->y_position = y_pos;
	}
	~Bug() {}

	int get_y_position() const override { return y_position; }

	void set_y_position(int val) override { y_position = val; }

	int get_x_position() const override { return x_position; }

	void set_x_position(int val) override { x_position = val; }
};


#endif

#ifndef ANT_H_
#define ANT_H_

#include "actor.h"
#include<memory>

class Ant : public Actor{
	int x_position, y_position;
public:
	Ant() : x_position(0), y_position(0) {}
	Ant(const int &x_pos, const int &y_pos){
		this->x_position = x_pos;
		this->y_position = y_pos;
	}
	~Ant() {}

	int get_y_position() const override { return y_position; }

	void set_y_position(int val) override { y_position = val; }

	int get_x_position() const override { return x_position; }

	void set_x_position(int val) override { x_position = val; }
};

#endif

Originally Posted by nvoigt

Your actor class has a position. If you implement it there, you don't need to implement it in your subclasses bug and ant again.

You Actor has a position, but your grid also saves the position. That's redundant. If one changes, the other might stay the same and you get an inconsistent state. You only need one entity in your model to save the position. Either the grid or the actors.

Your grid knows about bugs and ants. If there is a certain logic what happens to bugs or ants, maybe it would be better to put it in it's own class and keep the grid agnostic of the rules of play.

In general, you might want to let us know what you are trying to achieve. In plain normal english. Without code. Because although we might be good coders, we generally suck at telepathy. We don't know what you want. We only see what you tried. And it's hard to suggest better designs without a clue what the goal might be

I thought I did this a number of times above through the course of this thread.

What I want: To create a predator/prey simulator. Predators are bugs and the prey are ants. The predators and ants reside on a 2D grid 20 X 20. The predators and prey move randomly. If a predator encounters prey, it eats it. Otherwise they both move according to the same rules. The process of eating removes an ant.

Specifically: I want to put predators and prey represented as smart pointers onto the 20 X 20 grid. I do not want to store their position on a 2D vector of ints ... I want to put pointers to the bugs and ants on the 2D grid making their movement and removal from the grid easy.

The process of being eaten is as simple as calling release() on the shared pointer. I thought I was doing this but ran into problems.

I can not overstate, understate, rearrange, or re-communicate this any more. The info above is just copies of what I wrote previously.

Originally Posted by King Mir

If you have a grid of Actors that know about their own location on the grid, then that's redundant information; it means moving an Actor has to update two places. So you should probably not have Actors store their own location, only their age.

Also, shared_ptr is the wrong smart pointer here. You should use auto_ptr. auto_ptr is generally discouraged because it has weird copy semantics, but they happen to be what you want here. You could also use unique_ptr if you work around the copy semantics.

I will rework this problem based upon your input. I did read auto_ptr was replaced by a unique_ptr and recommends I should use a unique_ptr which has similar call semantics to shared_ptr but solely owns the object.

Why do you recommend the use of auto_ptr?

Originally Posted by King Mir

Because unique_ptr doesn't have a copy assignment operator. You can work around this, but auto_ptr is easier.

I can prob get around no copy or assign of unique_ptr by returning one from a function which the compiler allows just to stay in keeping with current convention.