Here’s my version of the anagram finder from Column 2: “Aha! Algorithms”.

#include <iostream>
#include <fstream>

#include <string>
#include <vector>
#include <unordered_map>
#include <algorithm>

typedef std::vector<std::string> anagram_vector_t;

typedef std::unordered_map<std::string, anagram_vector_t> anagram_map_t;

void
load_words_from_stream(anagram_vector_t& words, std::istream& input)
{
  std::string word;

  while(input >> word)
  {
    words.push_back(word);
  }
}

void
load_words_from_file(anagram_vector_t& words, const std::string& filename)
{
  std::ifstream input(filename);

  load_words_from_stream(words, input);
}

void
process_anagrams(const anagram_vector_t& words, anagram_map_t& anagrams)
{
  std::for_each(std::begin(words),
                std::end(words),
                [&anagrams](const std::string& word) {

    // get key by sorting the string value
    std::string key = word;
    std::sort(key.begin(), key.end());

    // store (key, value)
    anagrams[key].push_back(word);
  });
}

void
print_anagrams(const anagram_map_t& anagrams)
{
  for(auto i = std::begin(anagrams); i != std::end(anagrams); ++i)
  {
    const anagram_vector_t& words = i->second;

    if( words.size() > 1 )
    {
      std::for_each(std::begin(words),
                    std::end(words),
                    [&anagrams](const std::string& word) {

        std::cout << word << " ";
      });
      std::cout << std::endl;
    }
  }
}

void do_anagrams(const std::string& filename)
{
  anagram_map_t anagrams;
  anagram_vector_t words;

  load_words_from_file(words, filename);
  process_anagrams(words, anagrams);
  print_anagrams(anagrams);
}

int main(int argc, char *argv[])
{
  if( argc != 2 )
  {
    std::cout << "Usage: " << argv[0] << " <words-file>" << std::endl;
    return -1;
  }

  do_anagrams(argv[1]);

  return 0;
}

Here’s some company from my vacations…

Property p("zero", 0),

auto key = p.key();
auto value = p.value< int >();
auto tname = p.type();

Let’s start over with the simple stuff: the class declaration and some public types.

class Property
{
    public: // public types

    typedef std::string     key_t;
    typedef std::string     type_t;

To provide internal storage for the property value, define a Placeholder abstract class.

private:

    class Placeholder
    {
    public:

        Placeholder(const key_t& key) : key_(key) {}

        virtual ~Placeholder() {};

        virtual key_t key() { return key_; }
        virtual type_t type() const = 0;

    private:

        key_t key_;
    };

The Property class will store a pointer to Placeholder base class. This class provides for type-erasure since it does not mention the actual value type. The value is stored in the derived templated PlaceHolderStorage class.

    template < typename T >
    class PlaceholderStorage : public Placeholder
    {
    public:
        PlaceholderStorage(const key_t& key, const T& value):
            Placeholder(key), value_(value)
        {}

        virtual ~PlaceholderStorage() {}

        virtual type_t type() const
        {
            return typename_of< T >();
        };

        virtual const T& value()
        {
            return value_;
        }

    private:
        T value_;
    };

The default constructor of property created an integer value 0 and “default” as key. Default construction is only available to allow for usage with map standard container. Construction is also enabled by a template with the type of the storage data.

public:

    Property() :
        property_( new PlaceholderStorage< int >("default", 0) )
    {}

    template < typename T >
    Property(const key_t& key, const T& value) :
        property_( new PlaceholderStorage< T >(key, value) )
    {}

The Property allows access to the key and to the value. Access to the value requires a template type. A PropertyTypeInvalid exception is thrown if the requested type is not according to the stored value.

public:

    key_t key() const
    {
        return property_->key();
    }

    type_t type() const
    {
        return property_->type();
    }

    template < typename T >
    T value() const
    {
        PlaceholderStorage< T > *derived
            = dynamic_cast<
                PlaceholderStorage< T >* >(property_.get());

        if(derived == 0x0)
            throw PropertyTypeInvalid(
                std::string("Invalid property type, accessing \"")
                                + typename_of< T >()
                                + "\" value, but type is \""
                                + property_->type() + "\"");

        return derived->value();
    }

Internally, the Property stores the Placeholder for the data in a shared pointer.

private:

    std::shared_ptr< Placeholder > property_;
};

To access the complete example, access abyss source code.

So, what’s going on?

A long takes more that 1 byte (usually 4 bytes).
In big-endian 1 is represented by {0×00, 0×00, 0×00, 0×01}, which is reversed for little-endian {0×01, 0×00, 0×00, 0×00}. The code above takes the address of the most significant byte of the long, and depending on the value of that byte returns true if big-endian, false if little endian.

(click to enlarge)