static reference member

Currently I have a static pointer member to a std::vector<std::string>> in my abstract class.

Now I wonder is there a way to have a reference to a T instead of a pointer? The trouble I'm having is that I have to initialize it, and I don't want to because it would make no sense to statically initialize the member since the target is not global (as no variables should be).

I'd like to stay away from this pointer if there is a way but alas, maybe this class is doomed to fail in real life by the hands of C code.

You can't reassign references. So the answer is no.

But you can make the static pointer private and provide a static member function that returns a reference for the actual access.

Ok. Perhaps there is a better way to design this though. This is what I have and I don't know of a better way without using globals.

(next two blocks are in namespace Item)

Code:

---

        class Item {
                private:
                        const unsigned short sprite;

                public:
                        static const std::vector<std::string> *strings;

                        virtual void aquire()=0;

                        Item(const unsigned short&);
                        virtual ~Item();
        };

        Item::Item(const unsigned short& a): sprite{a} {}
        Item::~Item() {}

        const std::vector<std::string> *Item::strings{}; //the static construct

---

This is how Item will be used, as the strings std::vector.

Code:

---

        class Smallkey: public Item {
                public:
                        void aquire();

                        Smallkey();
        };

        Smallkey::Smallkey(): Item{0} {}

        void Smallkey::aquire() {
                std::cout<<(*strings)[0]<<std::endl;
        }

---

main, where assignment occurs.

Code:

---

//this is main
        const std::vector<std::string> strings{"Foo","Foo","Foo","Foo","Foo","Foo","Foo"};

        Item::Item::strings=&strings; //the relevant construct

---

edit: the reason I don't have the std::vector with the data in the actual class is because more classes will use this vector, and it will be loaded dynamically at run-time.

I don't see why you need static in the first place. Make an instance of the class and use it.
Furthermore, one instance is one item, so it makes sense to have several instances if you want several items.

Quote:

---

Originally Posted by Elysia

I don't see why you need static in the first place. Make an instance of the class and use it.
Furthermore, one instance is one item, so it makes sense to have several instances if you want several items.

---

Item is an abstract class. What exactly do you mean?

For example, if you wanted a player to have several items, then this might be in the player class:

Code:

---

std::vector< std::tr1::shared_ptr<Item> > m_Items;

---

And to add a new item, you would do:

Code:

---

m_Items.push_back( std::tr1::shared_ptr(new Smallkey) );

---

My problem is not relevant to how polymorphism works, I know that already. I want to know if there is a more beautiful way of, in my classes, accessing the strings loaded at run-time!

off-topic: isn't this just so elegant?

Code:

---

std::vector<Object::Object*> objects{
        new Object::Chest{new Item::Rupee{20}},
        new Object::Chest{new Item::Smallkey},
        new Object::Chest{new Item::Feather}
};

---

But as I try to explain, I fail to see why you need to. Why not take another, better approach?
Your approach is troublesome and definitely not a good polymorph-based approach for games.
And no, it's not elegant. You've replaced everything with { and }, including ( and ).

I'd like to see what that other, better approach is. Thereof this thread.

Hey you, it's C++0x uniform coolness!

My default choice would be to pass the string (or vector of strings if more than one is needed) to the acquire method. No good?

Quote:

---

Hey you, it's C++0x uniform coolness!

---

Must upgrade compiler :)

Quote:

---

Originally Posted by anon

My default choice would be to pass the string (or vector of strings if more than one is needed) to the acquire method. No good?

---

It's a lot of passing, my thought was it would be faster to just have the pointer at the abstract base. If not I would have to pass strings/vector with strings to every method that might use strings! I don't think it's abstract enough to implement. But what do I know.

Quote:

---

Originally Posted by anon

Must upgrade compiler :)

---

:-D If you are running Windows you can get weekly builds of gcc here Fortran, C, C++ for Windows this weeks' build will arrive today if it doesn't fail to compile! And if you didn't already know, compile your source with the argument -std=gnu++0x to make c++0x code work.

My next idea would be to give a reference/pointer to the vector to the objects in their constructor.

Actually, if you want the static vector, why does it have to be a pointer/reference? Why not simply add the strings to the static vector in main directly if you so wish?

Ok but wouldn't that end up in a lot of duplicate pointers? Maybe it's worth it from a design PoV though...

The magical re-assignable reference!

Code:

---

#include <iostream>

template < typename T >
class Reference
{
public:
    Reference( T &obj )
        : mPtr( &obj )
    {
    }

    Reference &operator=( const T &obj )
    {
        *mPtr = obj;
    }

    operator T&()
    {
        return *mPtr;
    }

    void Reassign( T &obj )
    {
        mPtr = &obj;
    }

private:
    T *mPtr;
};

void Foo( int &x )
{
    x = 30;
}

int main()
{
    int a, b, c;
    Reference< int > x ( a );

    x = 15; // You can assign
    std::cout << a << std::endl;
    x.Reassign( b ); // You can reassign to a different object
    x = 20;
    x == a; // You can compare
    Foo( x ); // You can pass it to a function that takes a reference
    // etc...
    std::cout << b << std::endl;
}

---

Now, this thing is evil -- don't use it! ;)

Quote:

---

The magical re-assignable reference!

---

Your operator=() has issues.