si se puede, pero tienes que crear la estructura para ello... aquí me fusilo este ejemplo

#include <iostream>
#include <vector>
using namespace std;
 
template <class T>
class AssocArray {
private:
 
    typedef struct _Data {
        T data;
        string name;
    } Data;
    vector<Data> stack;
public:
 
    long Size() {
        return stack.size();
    }
 
    bool IsItem(string name) {
        for (int i = 0; i < Size(); i++) {
            if (stack[i].name == name)
                return true;
        }
        return false;
    }
 
    bool AddItem(string name, T data) {
        if (IsItem(name))
            return false;
        Data d;
        d.name = name;
        d.data = data;
        stack.push_back(d);
        return true;
    }
 
    T& operator[](string name) {
        for (int i = 0; i < Size(); i++) {
            if (stack[i].name == name)
                return stack[i].data;
        }
        long idx = Size();
        Data d;
        d.name = name;
        stack.push_back(d);
        return stack[idx].data;
    }
 
    string GetItemName(long index) {
        if (index < 0)
            index = 0;
        for (int i = 0; i < Size(); i++)
            if (i == index)
                return stack[i].name;
        return "";
    }
 
    T& operator[](long index) {
        if (index < 0)
            index = 0;
        for (int i = 0; i < Size(); i++) {
            if (i == index)
                return stack[i].data;
        }
        return stack[0].data;
    }
 
};

y aquí el ejemplo de uso

//	Declare the class to be used with int data type
AssocArray<int> arr;
 
// Now add an element to the array using function
arr.AddItem("firstElement", 100);
 
// Now add an element using [] operator 
arr["secondElement"] = 25;
 
// Now add another element
arr["otherElement"] = 56;
 
// Here is how to access the element "firstElement" for any other purpose
cout << "firstElement = " << arr["firstElement"] << endl;
 
// Here is how to access using index
cout << "Element 1= " << arr[1] << endl;
 
 
// Other functions
// arr.IsItem("some element name") will return true if that item is on the array list or else false
// arr.GetItemName(2) will return the name of the element corresponding to index 2
// arr.Size()	will return the number of items saved on the list 
 

Si necesitas que los elementos se almacenen en orden, puedes usar std::pair y un vector:

#include <iostream>
#include <string>
#include <vector>
 
int main( )
{
  std::vector< std::pair< std::string, int > > elementos;
 
  elementos.push_back( std::make_pair( "firstElement", 100 ) );
  elementos.push_back( std::make_pair( "secondElement", 200 ) );
 
  for ( auto it = elementos.begin( ); it != elementos.end( ); ++it )
    std::cout << it->first << " " << it->second << std::endl;
}

Si te da igual el orden, puedes usar un mapa directamente

#include <iostream>
#include <map>
#include <string>
 
int main( )
{
  std::map< std::string, int > elementos;
 
  elementos.insert( "firstElement", 100 );
  elementos[ "secondElement" ] = 200;
 
  // volcado iterativo
  for ( auto it = elementos.begin( ); it != elementos.end( ); ++it )
    std::cout << it->first << " " << it->second << std::endl;
 
  // recuperar valores por claves:
  std::cout << "firstElement" << " " << elementos[ "firstElement" ] << std::endl;
  std::cout << "secondElement" << " " << elementos[ "secondElement" ] << std::endl;
}

auto es una palabra reservada de C++. Aparece a partir de C++11, por lo que si estás compilando con un compilador antiguo o que no tenga activa la opción C++11 (por ejemplo para MinGw hay que compilar con uno de estos dos flags, depende de la versión: -std=c++0x -std=c++11 )

lo que hace auto es dejar al compilador elegir el tipo de dato:

auto valor1 = 1; // valor sera de tipo int
auto valor2 = 14.5; // valor sera de tipo double

En el caso que ocupa el ejemplo, las siguientes dos líneas son equivalentes:

auto it = elementos.begin( );
std::vector< std::pair< std::string, int > >::iterator it = elementos.begin( );

Aquí se ve claro el motivo por el que uso "auto" en vez de su declaración formal, por claridad.

La otra ventaja que tiene usar "auto" es que si cambio la definición del contenedor no tengo que actualizar el uso del iterador, ya que "auto" hace ese trabajo por mí . Eso sí, esta palabra es mejor usarla con cuidado porque puede complicar la lectura del código y dar problemas si se usa de forma indiscriminada.

Ya que estamos hablando de esto, it es un iterador. Los iteradores se utilizan para recorrer contenedores en general. Es un elemento muy interesante e importante y saberlo usar aporta bastante potencia a la gestión de contenedores.

En este caso, el bucle for lo que está haciendo es crear un iterador que apunta al primer elemento del contenedor... y recorrerá todos los elementos del vector (++it) hasta que llegue al final.