Is it possible to pass a reference to a reference?

[xander333]

In example:

A GameState object has a reference to a RenderWindow object;
GameState holds an object called Level, which ALSO holds a reference to a RenderWindow object. When constructing Level, can I pass the RenderWindow object reference from my GameState class?

Well that was a little confusing to explain, I hope you understand!

[zb0S216C]

You can't pass a reference; only the referent.

_Wazzak

[xander333]

So in this case I should use pointers?

[Peter87]

It's not possible to have a reference to a reference. That would be totally useless because you can't modify a reference anyway.

You could let the Level constructor have a normal reference (to a RenderWindow object) as parameter.

[xander333]

Yes, that's what I meant...

[andywestken]

A slightly ambiguous question?

As I understand it, there's any problem passing a reference to another reference. Of course, the very first reference has got to refer to something. As is:

int x = 0;
int& y  = x; // y is a reference to x
int& z = y; // z is another reference to x, init via y 

So the answer to:

can I pass the RenderWindow object reference from my GameState class?

Is yes, you can. The two references end up referring to the same actual original variable.

Where I assume you mean this kind of thing:

#include <iostream>
#include <cstdio>

class RenderWindow {
private:
	std::ostream& m_os;
	RenderWindow& operator=(const RenderWindow&); // unused
public:
	RenderWindow(std::ostream& os) : m_os(os) {
	}
	void render(const char* msg) {
		m_os << msg << std::endl;
	}
};

class Level {
private:
	RenderWindow& m_rwnd;
	int m_id;
	Level& operator=(const Level&); // unused
public:
	Level(RenderWindow& rwnd, int id) : m_rwnd(rwnd), m_id(id) {
	}
	void report() {
		char msg[256] = "";
		sprintf(msg, "level id = %d", m_id);
		m_rwnd.render(msg);
	}
};

class GameState {
private:
	RenderWindow& m_rwnd;
	Level* m_pLevel;
	GameState& operator=(const GameState&); // unused
public:
	GameState(RenderWindow& rwnd) : m_rwnd(rwnd), m_pLevel(NULL) {
	}

	~GameState() {
		tearDown();
	}

	int init() {
		m_pLevel = new Level(m_rwnd, 42);
		return 0;
	}

	int tearDown() {
		if(NULL != m_pLevel) {
			delete m_pLevel;
			m_pLevel = NULL;
		}
		return 0;
	}

	int run() {
		m_rwnd.render("Hello world!");
		if(NULL == m_pLevel) {
			m_rwnd.render("<no level>");
		} else {
			m_pLevel->report();
		}
		return 0;
	}
};

int Run(RenderWindow& rwnd) {
	GameState gs(rwnd);
	int ret = gs.init();
	if(0 == ret) {
		ret = gs.run();
		gs.tearDown();
	}
	return ret;
}

int main() {
	int ret = 0;
	RenderWindow renderWindow(std::cout);
	RenderWindow& rwnd = renderWindow;
	ret = Run(rwnd);
	return ret;
}