I've been using .NET forever now, and with speedhack comming up, I want to get back into the feel of C++.

.NET has spoiled me with it's super easy generic collections (System.Generic.Collections) Where you can declare in VB "List(Of String)" or "List(Of Integer)" or "List(of List(of MyType))" ooh and dictionaries too!

Basically a list collection is strongly typed and starts out empty (it has a Count property that tells you how many items there are in the collection, and you can refer to your items by property), and you add items to it with it's Add method, and remove them with the RemoveAt or Remove (removeat takes an index, and remove takes a pointer to the item.)

I think these types of collections already exist in C++ (but I'm more of a C programmer, so I've never known about them.) I could write the collection myself if it doesn't exist, but it'd be more convient if I understood the C++ equivalent of generics (am I wrong in assuming C++ templates can do this?)

[/n00b]

STL does that, but .NET's Generics are, IMO, more powerful and nicer to use.

I should have also mentioned that it's useless to learn STL without the algorithms as well.

http://cppreference.com/cppalgorithm/index.html
It also adds a flare of functional programming to C++.

Can you do this in .NET?

#include <boost/spirit/phoenix.hpp>

// lets find if there is some odd numbers here...
if ( find_if(c.begin(), c.end(), arg1 % 2 == 1) != c.end() ) {
   // yap, there is something odd here ;-)
}

See http://spirit.sourceforge.net, and go to Phoenix (library).

By the way, you are not using C++ if you don't use libraries, STL is the basic one, but there is much more... see http://www.boost.org too.

How to sort:

#include <vector>
#include <algorithm>
vector<string> c;
// ...
sort( c.begin(), c.end() );

Very easy. To swap use "swap" and "swap_range", although with all those algorithms out of the box, it isn't needed so much.

It's not special, it is amazing!!!!

You can put the function body while you call the algorithm, it's functional programming at its best..., for me, it is great!

The find_if function will return an iterator to the first element that meet the requirement (which can be any function), if there is no one, it will return the second parameter (i.e. an iterator to the end of the range), this is why I put " ... != c.end()", the condition will be true if there is at least one element which is odd.

EDIT: Yes, there is a dictionary, but it is called a "map":

#include <map>

map<string, int> distances;

distances["Canada"] = 500;

You could always use D/DAllegro if you're just concerned about Speedhack.

The boost library is really a collection (20+) of libraries, so you just pick the one you want to use, they are not big, really, most of them are just "header only" libraries, and very useful, shared_pointer and lexical_cast comes to my mind.

I've explained the code in the EDIT part

By the way, I'll check D/DAllegro

C++0x is going to be adding lambda expressions.. sadly the ones from boost/lambda It is a step up from std::bind1st and std::plus etc. but it is clearly a hack of the worst kind. The most evil part: COMPILER ERRORS!1111

C# 3.0 has added lambda expression from what i can tell. I really really wish c++ allowed that kind of anonymous functions.

double[string] Dict;
Dict["Hello World"] = 52.5;
Dict["PI"] = 3.14159;
Dict["Your Mom's"] = 5318008;
  
foreach(key, val; Dict)
{
  writefln("%s = %s", key, val);
}

But no, D doesn't have a very advanced toolset to work with. But I'd rather use it without, than use C++ with.

I use UltraEdit with syntax highlighting and the standard gdb debugger.

I wrote this piece of code. Compiled and worked first try *which is rare for me in c++ sadly.

Btw.. pair is a tuple of size 2.

if i inline print_pair using boost/lambda it will look like this. Notice how boost lambda sucks balls for even a simple example.

C++'s has a crap load of list features. I've never used a language with more.

{"name":"containerchoice.png","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/c\/0c0f8b542e5ce053a092a917da542369.png","w":684,"h":707,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/c\/0c0f8b542e5ce053a092a917da542369"}

std::set is (i think) the coolest. Mainly due to its weirdness. std::multi_set is ofcourse even stranger o_O

That's a neat flowchart dustin, geeky (it being a flowchart about STL containers), but neat. Of those i often use vector, list, deque and map.

Doesn't Java have the exact same containers (only with slightly different names)?
Hmm. maybe it lacks multi_set/multi_map (they are pretty much just a map<yourkey,vector<yourvalue> > anyway).

A good alternative to C++ arrays:

Use the Glib !

Manual

Table of Contents

GLib Fundamentals

* Basic Types — standard GLib types, defined for ease-of-use and portability.
* Limits of Basic Types — portable method of determining the limits of the standard types.
* Standard Macros — commonly-used macros.
* Type Conversion Macros — a portable method for storing gint & guint values in gpointer variables.
* Byte Order Macros — a portable way to convert between different byte orders.
* Miscellaneous Macros — specialised macros which are not used often.

GLib Core Application Support

* The Main Event Loop — manages all available sources of events.
* Threads — thread abstraction; including mutexes, conditions and thread private data.
* Dynamic Loading of Modules — portable method for dynamically loading 'plug-ins'.
* Memory Allocation — general memory-handling.
* IO Channels — portable support for using files, pipes and sockets.
* Message Output and Debugging Functions — functions to output messages and help debug applications.
* Message Logging — versatile support for logging messages with different levels of importance.

GLib Utilities

* String Utility Functions — various string-related functions.
* Date and Time Functions — calendrical calculations and miscellaneous time stuff.
* Hook Functions — support for manipulating lists of hook functions.
* Miscellaneous Utility Functions — a selection of portable utility functions.
* Lexical Scanner — a general purpose lexical scanner.
* Automatic String Completion — support for automatic completion using a group of target strings.
* Timers — functions to time operations.
* Windows Compatability Functions — functions to support portability to the Windows environment.

GLib Data Types * Memory Chunks — efficient way to allocate groups of equal-sized chunks of memory. * Doubly-Linked Lists — linked lists containing integer values or pointers to data, with the ability to iterate over the list in both directions. * Singly-Linked Lists — linked lists containing integer values or pointers to data, limited to iterating over the list in one direction. * Hash Tables — associations between keys and values so that given a key the value can be found quickly. * Strings — text buffers which grow automatically as text is added. * String Chunks — efficient storage of groups of strings. * Arrays — arrays of arbitrary elements which grow automatically as elements are added. * Pointer Arrays — arrays of pointers to any type of data, which grow automatically as new elements are added. * Byte Arrays — arrays of bytes, which grow automatically as elements are added. * Balanced Binary Trees — a sorted collection of key/value pairs optimised for searching and traversing in order. * N-ary Trees — trees of data with any number of branches. * Quarks — a 2-way association between a string and a unique integer identifier. * Keyed Data Lists — lists of data elements which are accessible by a string or GQuark identifier. * Datasets — associate groups of data elements with particular memory locations. * Relations and Tuples — tables of data which can be indexed on any number of fields. * Caches — allows sharing of complex data structures to save resources. * Memory Allocators — allocates chunks of memory for GList, GSList and GNode.