I've known of and have been using the std::vector class for about a dozen weeks now, primarily while making my graphics application, and I'm starting to wonder how I ever programmed without it!

For starters, making the file handler for my graphics program has been absolute Hell... specifically because of all the nuances in what the thing should do when you click on certain things, or type in certain file names, or switch your desired file format, etc. etc. But the process of actually creating the list of files from the current working directory was extremely simple, thanks to _stricmp() for sorting and the findfirst() and findnext() functions to get the filenames, but most importantly, the std::vector object that holds the list of filenames and file attributes without having to do messy memory allocation or whatnot.

I've also got std::vector objects holding the brush history, undo history, and bitmap pages.

I've been slowly losing my desire to work with static arrays, which, 12 weeks ago, I was convinced would never happen. As a result, I've been going through the docs for my game engine and the first game I'm going to make with it and altering many of their static-allocated features to be dynamic. (Some of the static-ness is still there, but only where it makes sense to have small, predefined limits.)

The new and delete commands make perfect sense to me now as well, and I haven't touched malloc() or calloc() since PixelShips Retro, though it took over half an hour for me to fix a bug in my graphics program that involved nothing more than changing "BITMAP *bitmap" in a function definition to a "BITMAP *&bitmap"...

...so I guess stupid mistakes are still going to happen...

Anyways, I'm fully confident in using dynamic arrays and std::vector objects now, and it's hard to imagine that I used to program without them not long ago...

--- Kris Asick (Gemini)
--- http://www.pixelships.com

Don't stop at std::vector. Take a look at STL. STL offers a number of simple algorithms. std::copy, transform, find_max, etc. all make life much simpler.

And then when you're really serious take a look at boost. Boost is doing such a good job that most of the C++0x library changes (ie: the next c++ standard) is coming from the boost libraries. In fact, its the same way that the STL (including std::vector) managed to work its way into C++ everywhere.

std::map is also quite handy in certain cases.

Oh, and don't forget std::string. It isn't the best, by far, but with a handy to_string template function life is a breeze.

template<typename T>
std::string to_string(const T &value)
{
  std::ostringstream ret;
  ret << value;
  return ret.str();
}

I very often use STD vector, though occasionally use an array for some things that are small, delicate, and have a defined max size.

Niiice. I don't actually use boost, just the BOOST_FOREACH header. But that's a neat trick anyway.

// After after
BOOST_FOREACH(string item, strings)
     item.foobar();

Now make your code go over some arbitrary memory, or how about even a subset of the strings list...

Right. And thats why I use the STL. Boost is mostly crap anyway. This sort of method: boost::lexical_cast should not be using stringstream anyway, thats tons of unnecessary overhead. There are more efficient ways to do that.

Boost is generally lame anyway. Its key "popular" features are just thin wrappers around C++ features.

And come on, macros? I thought we were done with those.

for_each(a.begin(), a.end(), 
         if_(_1 % 2 == 0)[ cout << _1 ])

template<int power, typename Parm>
bool powerOf(Parm p) { return p % power == 0; }

^^ put that in a header somewhere, very reusable.
Now to do ugly lambada crap in a clean way:

copy_if(a.begin(), a.end(), ostream_iterator<int>(cout), PowerOf<2>);

Most of whats is being shown here are just neat tricks that help you stand out from being a good programmer to being a better programmer.

Now regarding the work place it really depends. For a database programming job, chances are you wont need to know anything here. Very rarely is database code done in C++, and if it is, it's going to be abstracted away some how.

.Net, Java etc are languages that you'll find most database jobs use and they wont need any of these clever hacks. Mostly because stuff like this is built into the language, or added in someway.(For each loops are the best example).

Now if you're developing a C++ program in your job, then it could be. However you want to avoid being too fancy with this kind of stuff since it might work nice, but some other people might not understand the code etc. But in the end its not necessary and clean and easy to understand and efficient is more important then using neat tricks to simplify things. In fact depending on the requirements of the project, you might not even be able to do some stuff you would like.

Now if your asking if you need to the STL to code C++ apps, and you better be familiar with STL and not just learning it for the first time when you walk in.

You really want to use different STL containers for different purposes. Look into deque, set, map and list as well, not only vector, and get familiar with them, so you can pick the right thing for the task at hand.

Yeah, but at least its reusable.

if(powerOf<5>(25))
  cout << "25 is a power of 5!\n";

Tobais, that already exists:

vector<string> mystrlist;
std::copy(mystrlist.begin(), mystrlist.end(), ostream_iterator<string>(cout, "item seperator"));

WOW, this article got me looking into vectors, I had heard about them before but never understood how to use them, now I'm in the same boat as you and don't know how I got by without them!

I WUB WOOOOUU!!
sorry, read vgcats on vgcats.com to understand.