Does anyone here have a sample of code they used for data in thier game which uses Vectors?

Yes, me and my Eglish teacher did not see eye to eye.

Do you mean vectors as used to draw elements, or used as a way to calculate positions...?

Or are you talking about std::vector? For that, check out either this or this site.

I'm really tired (waiting for a backup process to complete) so I'm not going to test it, but if I made no mistakes it should output:

[1,12,23,34,45,56]
[1,12,23,34,45,56]

The real difference is that when you're adding items to a vector, you use push_back(), like bamccaig showed. (Note to bamccaig: Line 35 )

Once you've pushed all of the numbers onto the array that you want, you can index them with the normal "[]" brackets like you do with a normal array:

  std::vector<int> array;
  array.push_back(10);
  array.push_back(-13);
  // ...
  array.push_back(6);

  int current_value = array[0]; // 0th element, value of "10"
  int next_value = array[1];    // 1st element, value of "-13"
  // ...

EDIT:

Yes, absolutely you can do something like this. That's what the std::vector was made for. You define the "type" of vector using the "<" and ">" brackets:

Yeah I saw the error of my ways after the last two responses were given...

In regards to LennyLen post, if I delete GoodGuys[5], would GoodGuys[6]'s data take it's place an so on until the entire Vector was one shorter in length?

GoodGuys.erase(GoodGuys.begin() + 4);  // erases GoodGuys[5]

[EDIT]

Vector reminds me of the push pop in Assembly Language.

Your pretty smart for a Cop...Wolf...

I'm looking at erasing a vector each time a troop dies. So it would be about 1 every 2 mins or so. And my vector Struct will contain 8 kingdoms worth of 20-50 troops.

Vector sounds like the way to go...but I'll read about the List you are talking about.

Goalie:
Explain that for me; I'm not used to c++0x.

Nakhash: Since you're not going to be removing them every second, std::vector sounds about right for you. The only two things you'll want to consider when doing this is:
1) If you have a LOT of elements in the array, and you remove Troops from (or near) the front of that vector, you'll have a lot of shifting to do.
2) If the order of the troops don't matter much in the overall design of the game, swapping the last element with the to-be-removed element should be considered.

I don't know how much you've worked with pointers, but I've actually found it worthwhile for me to store a vector of points to the structs/classes that I've created. Then, if you do something like "array[current_index] = array[another_index];", it won't COPY the object using the object's assignment operator ( Troop& operator= (const Troop& rhs); ). It will just copy the pointer address and you're done.

The only real overhead you have with this is that you must call new() and delete() yourself. Passing by reference, instead of passing by pointer, does all of this for you (even calling the destroyed object's destructor when appropriate), though you incur the "deep" or "shallow" copy I just mentioned.

You can use <quote>...</quote> tags if it helps.

Okay...

Since your

and your

contain two of the same variables, why not use inheritance?

struct ClassDef
{
  int Strength;
  int Defense;
};

struct UnitsDef : public ClassDef 
{
  int ClassID;
  int Level;
  // UnitsDef now contains Strength and Defense, as inherited from ClassDef
};

Now, if I've broken this down correctly, you have:

• 20 "Class" objects, each with two ints (4 bytes apiece)

• 8*50 == 400 "Units" objects with four ints (4 bytes apiece)

• 25 "PlayerTroops" objects with four ints (4 bytes apiece)

That's (20 * 8) * (400 * 16) * (25 * 16) bytes, or 409,600,000 bytes of data you're storing in memory, whether all of them are filled or not with actual data.

Yes, I'd definitely go with the vector approach, and only allocate them as needed.

I don't think inheritance will work for me since I haven't fully repersented my variables in each struct. I've been going off memory to show how I'm using the data.

So in other words ClassDef has variables that UnitDef doesn't have and the Class Strength should also be a different number then the Units Strength.

I've been using ClassDef as an intro set of stats for my troops, and it also contains graphical X,Y cordance data for my sprite bitmaps that correspond to the correct Class(Job..Ex..Archer..Wizard)/Race

I do appreciate all of your guys help.

Okay I will.. someone please bookmark/remind me to make a wiki if this ends up being referred to in other posts.

//use case: -(vec1 + vec2)
//modifies and returns the unnamed vector 
//created from (vec1 + vec2)
//requires c++0x
Vec2D&& operator-( Vec2D&& vec )
{
  vec.x = -vec.x;
  vec.y = -vec.y;
  return std::move(vec);
}

So, in C++ there are r-values and l-values. An r-value is a value without an explicit name.. these are temporary objects that can only be accessed in one way.

Vec2D a(1,2);
Vec2D b(-1,2);

Vec2D c = (a + b) - b;

In this example a,b,c are named variables. That means that any line of code in that scope can use the label (ie: name) to access that object.

(a+b) is a function of named variables a and b and returns a variable. What is this variable called? It is unnamed therefore nowhere else in the code can touch that result. This means that we can make an optimization here! Let us re-use the result from (a+b) by storing the result of (a+b)-b into the temporary created by (a+b).

Vec2D&& operator-(Vec2D&& ab, const Vec2D& b)
{
   ab.x -= b.x;
   ab.y -= b.y;
   return std::move(ab);
}

So && is the C++0x notation for r-value. Once we give an r-value a name it becomes an l-value. So ab is an l-value. But we want to return an r-value here so we use std::move which simply casts an l-value to an r-value. Notice how we re-use the temporary ab rather than making a new-copy!

std::move does nothing but cast from Var& to Var&&. Where is the code that runs the actual test?

Say for example you had a string..

string&& operator+( string&& a, const string& b )
{
 //some magic
}

//write out other permutations of arguments...

string& operator+( const string& a, const string& b)
{
 //some different magic
}

Then you would see a great performance increase from something like this

string c = a + b + "hello world " + d + e + f + g + "something else ";

In many programming languages they say avoid doing this because it constructs a new string for every addition and then throws it away. A lot of language tell you to use a.join etc. With r-values you can mimic that join behavior with a naive syntax.