C++ returning class object through multiple function - c++

Question

I'm trying to pass custom object (TextureInfos) through multiples functions.
The call is:
TextureManager::Instance()->getTextureInfos("TEST",0)
TextureManager.cpp
TextureInfos& TextureManager::getTextureInfos(std::string key, int id)
{
TextureSet textureSet = textureSets[key];
return textureSet.getTextureInfos(id);
}
TextureSet .cpp
TextureInfos& TextureSet::getTextureInfos(int id)
{
sf::Texture texture;
sf::IntRect rect;
if (id < tileCount) {
int x = (id % maxCol) * tileWidth;
int y = (id / maxCol) * tileHeight;
rect.left = x;
rect.top = y;
rect.width = tileWidth;
rect.height = tileHeight;
}
TextureInfos *textureInfos = new TextureInfos(texture,rect);
return textureInfos;
}
I'm new to C++ and I think I miss something with the operator "&" and "*" etc. Because this code does not work for the moment...
Any help?
Thanks a lot.
EDIT:
Ok so the purpose of this code is to get a TextureInfos object at the end of the process. For this, I need to call the getTextureInfos method from TextureManager which also call getTextureInfos from TextureSet.
Here is the complete code for TextureManager.cpp
#include "TextureManager.h"
#include <iostream>
#include <fstream>
TextureManager TextureManager::m_TextureManager;
const std::string basePath="Assets/Graphics";
#pragma region Constructor
TextureManager::TextureManager()
{
textureSets.clear();
}
TextureManager::~TextureManager()
{
}
#pragma endregion
#pragma region Textures management
// Charge un set de texture a partir d'un nom de fichier
void TextureManager::LoadTextureset(std::string fileName,std::string key) {
TextureSet textureSet;
textureSet.init(basePath + fileName, key);
textureSets[key] = textureSet;
}
// Récupère une texture de la liste
TextureInfos TextureManager::getTextureInfos(std::string key, int id)
{
TextureSet textureSet = textureSets[key];
return textureSet.getTextureInfos(id); // HERE I GET AN ERROR
}
#pragma endregion
The line which is commented at the end is where i got an error:
no suitable user-defined conversion from "TextureInfos" to "TextureInfos" exists.
And for TextureSet.cpp:
#include "TextureSet.h"
#include <iostream>
#include <fstream>
#include "RapidXML\rapidxml.hpp"
#include "Debug.h"
const std::string basePath="Assets/Graphics";
using namespace rapidxml;
#pragma region Constructor
TextureSet::TextureSet()
{
}
TextureSet::~TextureSet()
{
}
#pragma endregion
void TextureSet::init(std::string l_filePath,std::string l_key)
{
filePath = l_filePath;
key = l_key;
// On détermine les URLs des fichiers
std::string setDescriptorPath = filePath + ".xml";
std::string setTilesetPath = filePath + ".png";
// On charge la texture
if (!textureSet.loadFromFile(setTilesetPath))
throw "ça load pas";
// On lis le xml
std::ifstream xmlDescriptor(setDescriptorPath);
if(!xmlDescriptor)
throw "Could not load tileset: " + setDescriptorPath;
std::string xmlDescriptorContents;
{
std::string line;
while(std::getline(xmlDescriptor, line))
xmlDescriptorContents += line;
}
std::vector<char> xmlData = std::vector<char>(xmlDescriptorContents.begin(), xmlDescriptorContents.end());
xmlData.push_back('\0');
//Create a parsed document with &xmlData[0] which is the char*
xml_document<> doc;
doc.parse<parse_no_data_nodes>(&xmlData[0]);
//Get the root node
xml_node<>* root = doc.first_node();
xml_node<>* imagefile = root->first_node("params");
maxRow = atoi(imagefile->first_attribute("maxRow")->value());
maxCol = atoi(imagefile->first_attribute("maxCol")->value());
tileWidth = atoi(imagefile->first_attribute("tileWidth")->value());
tileHeight = atoi(imagefile->first_attribute("tileHeight")->value());
tileCount = atoi(imagefile->first_attribute("tileCount")->value());
}
TextureInfos TextureSet::getTextureInfos(int id)
{
sf::Texture texture;
sf::IntRect rect;
if (id < tileCount) {
int x = (id % maxCol) * tileWidth;
int y = (id / maxCol) * tileHeight;
rect.left = x;
rect.top = y;
rect.width = tileWidth;
rect.height = tileHeight;
}
TextureInfos textureInfos(texture,rect);
return textureInfos;
}
TextureInfos.h
#include <unordered_map>
#include <vector>
#include <SFML\Graphics.hpp>
#include <string>
class TextureInfos
{
private:
protected:
public:
TextureInfos(sf::Texture& l_texture, sf::IntRect l_textureRect);
~TextureInfos();
sf::Texture& texture;
sf::IntRect textureRect;
};

Answer 1

No it doesn't work because it doesn't even compile. The reason it doesn't compile is because you try to return a pointer as a reference. A pointer and a reference are two different things.
For a quick, simple and dirty fix, change the return types from from TextureInfos& to TextureInfos*.
The quick fix outlined above is "dirty" because as you are using the code you will have a memory leak (you allocate memory with new but don't free it).
That can be solved two ways: Either return by value instead of using pointers/references. Or use smart pointers such as std::unique_ptr.

Answer 2

If you can avoid the use of dynamic memory allocation just edit your TextureSet::getTextureInfos to return a new stack object by value (notice that there will be a Return Value Optimization if you are worried about efficiency):
TextureInfos TextureSet::getTextureInfos(int id)
{
// ...
return TextureInfos(texture, rect);
}
Otherwise, if you really need dynamic allocation, use an std::shared_ptr to avoid memory leaks:
std::shared_ptr<TextureInfos> TextureSet::getTextureInfos(int id)
{
// ...
return std::make_shared<TextureInfos>(texture, rect);
}

Answer 3

According to your object naming I am assuming that you want to have a set of objects in your TextureSet. I would therefore suggest to add a private variable to your Object, and test new get requests against this object. You can then safely return a reference to a member.

Answer 4

One think that looks very worrying is that TextureInfos holds a reference to a texture, and you construct one from a passed reference.
TextureInfos(sf::Texture& l_texture, sf::IntRect l_textureRect);
sf::Texture& texture;
sf::IntRect textureRect;
Assuming the constructor does something like this
TextureInfos(sf::Texture& l_texture, sf::IntRect l_textureRect) :
texture(l_texture),
textureRect(l_textureRect)
{
}
... then you are entering a world of much pain. Look at GetTextureInfos() to see why:-
TextureInfos& TextureSet::getTextureInfos(int id)
{
sf::Texture texture;
sf::IntRect rect;
...
TextureInfos *textureInfos = new TextureInfos(texture,rect);
return textureInfos;
}
Ignoring the obvious issue that this will likely leak the returned object, you have the major problem that the returned object holds a reference to texture - but texture has gone out of scope so is no longer valid!
I can't propose a simple solution - but you need to make sure that you understand the lifetime management and ownership issues of the objects you're creating. Smart pointers (and returning entire objects rather than references) are usually key parts of this.