Sure, no worries! :-)

Yeah, good point on the hyphens!
There's nothing better to motivate/appreciate Boost than doing it the hard way first ;-)

As for std::size_t as *the* good-for-counting-type: arguably, "in general" [x], yes.

For instance, here's Scott Meyers using it for counting: http://www.drdobbs.com/cpp/counting-objects-in-c/184403484

Here's Andrew Koenig on the matter:
http://www.drdobbs.com/cpp/the-case-against-int-part-1/232601393
http://www.drdobbs.com/cpp/the-case-against-int-part-2-why-signed-i/232601914
http://www.drdobbs.com/cpp/the-case-against-int-part-3-the-advantag/232602212

(Part 3) "C++ defines an unsigned integer type, size_t, that is well-suited to storing array indices, or otherwise counting items that can fit in the computer's memory.

Last week, I noted that integers are often used for counting, and that counting is often better suited to unsigned than to signed arithmetic. To that end, C++ defines an unsigned integer type, size_t, that is well-suited to storing array indices, or otherwise counting items that can fit in the computer's memory. Moreover, each of the standard-library containers, such as vector<T>, defines a type analogous to vector<T>::size_type, which is an unsigned integer with an appropriate capacity to store the number of elements in a vector<T>."

Although, in terms of full disclosure, he also considers "unsigned long" (part 2):

"For example, a common use of integers is to count things: the number of students in a course, cars in a parking lot, records in a file, and so on. In general, counters cannot be negative; so unsigned types are often more appropriate than signed integer types such as int. Moreover, one common use of such integers is as array or container indices or sizes. For built-in data structures, C++ provides the unsigned type size_t and the corresponding signed type ptrdiff_t; moreover, each library container type has its own size_type that has room for the number of elements in the largest container of each type. So for counting things that can fit in memory, you are probably better off using size_t or container::size_type than you are in using int, or even unsigned. For counting items in files, unsigned long is probably right."

For more, see also:
- About size_t and ptrdiff_t: http://www.viva64.com/en/a/0050/
- A 64-bit horse that can count: http://www.viva64.com/en/a/0043/
- Memsize-type: http://www.viva64.com/en/t/0030/
- Mixed use of simple integer types and memsize types: http://www.viva64.com/en/a/0004/#ID0EOAFM

For even more, see:
http://stackoverflow.com/questions/994288/size-t-vs-int-in-c-and-or-c
http://stackoverflow.com/questions/918567/size-t-vs-containersize-type
http://stackoverflow.com/questions/12997600/choosing-between-size-t-and-containersize-type-in-compile-time

[x] -- qualifications & caveats reserved due to enormous variety of possible C++ applications ;-) Here, the focus is on being future-proof & cross-platform, with an extra benefit of readable, self-documenting code (expressing the intent to count). There are, however, specific situations where we'd rather be platform-specific, sacrificing generality/readability, e.g., low-level communication protocols, network card drivers (where you know how many bits are representing, say, a packet size, and want to ensure this doesn't change), structures intended for serialization (where you explicitly *don't* want the benefits of size_t scaling to match your architecture word, but would rather have a fixed-width type so as to ensure compatibility) -- in these cases you'd consider fixed width integer types /* http://en.cppreference.com/w/cpp/types/integer */ (and, obviously, "int" and "unsigned int" would be out of the running, for the same reasons) -- although, IMHO, a typedef (clarifying the intent to use one of these as a count/size type) would still be a good idea.
// containers have their own size_type, nothing wrong with using it, although it may often (i.e., as long as you stay with the standard allocators) be just a typedef to std::size_t;