diff --git a/taglib/ape/apetag.cpp b/taglib/ape/apetag.cpp
index 97a3fb53..5d6c521b 100644
--- a/taglib/ape/apetag.cpp
+++ b/taglib/ape/apetag.cpp
@@ -208,14 +208,16 @@ namespace
 {
   // conversions of tag keys between what we use in PropertyMap and what's usual
   // for APE tags
-  //                                    usual,         APE
-  const char *keyConversions[][2] =  {{"TRACKNUMBER", "TRACK"       },
-                                      {"DATE",        "YEAR"        },
-                                      {"ALBUMARTIST", "ALBUM ARTIST"},
-                                      {"DISCNUMBER",  "DISC"        },
-                                      {"REMIXER",     "MIXARTIST"   },
-                                      {"RELEASESTATUS", "MUSICBRAINZ_ALBUMSTATUS" },
-                                      {"RELEASETYPE", "MUSICBRAINZ_ALBUMTYPE" }};
+  //                usual,         APE
+  const std::pair<const char *, const char *> keyConversions[] = {
+    std::make_pair("TRACKNUMBER", "TRACK"),
+    std::make_pair("DATE",        "YEAR"),
+    std::make_pair("ALBUMARTIST", "ALBUM ARTIST"),
+    std::make_pair("DISCNUMBER",  "DISC"),
+    std::make_pair("REMIXER",     "MIXARTIST"),
+    std::make_pair("RELEASESTATUS", "MUSICBRAINZ_ALBUMSTATUS"),
+    std::make_pair("RELEASETYPE", "MUSICBRAINZ_ALBUMTYPE"),
+  };
   const size_t keyConversionsSize = sizeof(keyConversions) / sizeof(keyConversions[0]);
 }  // namespace
 
@@ -233,8 +235,8 @@ PropertyMap APE::Tag::properties() const
     else {
       // Some tags need to be handled specially
       for(size_t i = 0; i < keyConversionsSize; ++i) {
-        if(tagName == keyConversions[i][1])
-          tagName = keyConversions[i][0];
+        if(tagName == keyConversions[i].second)
+          tagName = keyConversions[i].first;
       }
       properties[tagName].append(it->second.toStringList());
     }
@@ -255,9 +257,9 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
 
   // see comment in properties()
   for(size_t i = 0; i < keyConversionsSize; ++i)
-    if(properties.contains(keyConversions[i][0])) {
-      properties.insert(keyConversions[i][1], properties[keyConversions[i][0]]);
-      properties.erase(keyConversions[i][0]);
+    if(properties.contains(keyConversions[i].first)) {
+      properties.insert(keyConversions[i].second, properties[keyConversions[i].first]);
+      properties.erase(keyConversions[i].first);
     }
 
   // first check if tags need to be removed completely
diff --git a/taglib/asf/asftag.cpp b/taglib/asf/asftag.cpp
index 75249121..a23bf1b7 100644
--- a/taglib/asf/asftag.cpp
+++ b/taglib/asf/asftag.cpp
@@ -210,60 +210,60 @@ bool ASF::Tag::isEmpty() const
 
 namespace
 {
-  const char *keyTranslation[][2] = {
-    { "WM/AlbumTitle", "ALBUM" },
-    { "WM/AlbumArtist", "ALBUMARTIST" },
-    { "WM/Composer", "COMPOSER" },
-    { "WM/Writer", "LYRICIST" },
-    { "WM/Conductor", "CONDUCTOR" },
-    { "WM/ModifiedBy", "REMIXER" },
-    { "WM/Year", "DATE" },
-    { "WM/OriginalReleaseYear", "ORIGINALDATE" },
-    { "WM/Producer", "PRODUCER" },
-    { "WM/ContentGroupDescription", "GROUPING" },
-    { "WM/SubTitle", "SUBTITLE" },
-    { "WM/SetSubTitle", "DISCSUBTITLE" },
-    { "WM/TrackNumber", "TRACKNUMBER" },
-    { "WM/PartOfSet", "DISCNUMBER" },
-    { "WM/Genre", "GENRE" },
-    { "WM/BeatsPerMinute", "BPM" },
-    { "WM/Mood", "MOOD" },
-    { "WM/ISRC", "ISRC" },
-    { "WM/Lyrics", "LYRICS" },
-    { "WM/Media", "MEDIA" },
-    { "WM/Publisher", "LABEL" },
-    { "WM/CatalogNo", "CATALOGNUMBER" },
-    { "WM/Barcode", "BARCODE" },
-    { "WM/EncodedBy", "ENCODEDBY" },
-    { "WM/AlbumSortOrder", "ALBUMSORT" },
-    { "WM/AlbumArtistSortOrder", "ALBUMARTISTSORT" },
-    { "WM/ArtistSortOrder", "ARTISTSORT" },
-    { "WM/TitleSortOrder", "TITLESORT" },
-    { "WM/Script", "SCRIPT" },
-    { "WM/Language", "LANGUAGE" },
-    { "WM/ARTISTS", "ARTISTS" },
-    { "ASIN", "ASIN" },
-    { "MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID" },
-    { "MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID" },
-    { "MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID" },
-    { "MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
-    { "MusicBrainz/Album Release Country", "RELEASECOUNTRY" },
-    { "MusicBrainz/Album Status", "RELEASESTATUS" },
-    { "MusicBrainz/Album Type", "RELEASETYPE" },
-    { "MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
-    { "MusicBrainz/Release Track Id", "MUSICBRAINZ_RELEASETRACKID" },
-    { "MusicBrainz/Work Id", "MUSICBRAINZ_WORKID" },
-    { "MusicIP/PUID", "MUSICIP_PUID" },
-    { "Acoustid/Id", "ACOUSTID_ID" },
-    { "Acoustid/Fingerprint", "ACOUSTID_FINGERPRINT" },
+  const std::pair<const char *, const char *> keyTranslation[] = {
+    std::make_pair("WM/AlbumTitle", "ALBUM"),
+    std::make_pair("WM/AlbumArtist", "ALBUMARTIST"),
+    std::make_pair("WM/Composer", "COMPOSER"),
+    std::make_pair("WM/Writer", "LYRICIST"),
+    std::make_pair("WM/Conductor", "CONDUCTOR"),
+    std::make_pair("WM/ModifiedBy", "REMIXER"),
+    std::make_pair("WM/Year", "DATE"),
+    std::make_pair("WM/OriginalReleaseYear", "ORIGINALDATE"),
+    std::make_pair("WM/Producer", "PRODUCER"),
+    std::make_pair("WM/ContentGroupDescription", "GROUPING"),
+    std::make_pair("WM/SubTitle", "SUBTITLE"),
+    std::make_pair("WM/SetSubTitle", "DISCSUBTITLE"),
+    std::make_pair("WM/TrackNumber", "TRACKNUMBER"),
+    std::make_pair("WM/PartOfSet", "DISCNUMBER"),
+    std::make_pair("WM/Genre", "GENRE"),
+    std::make_pair("WM/BeatsPerMinute", "BPM"),
+    std::make_pair("WM/Mood", "MOOD"),
+    std::make_pair("WM/ISRC", "ISRC"),
+    std::make_pair("WM/Lyrics", "LYRICS"),
+    std::make_pair("WM/Media", "MEDIA"),
+    std::make_pair("WM/Publisher", "LABEL"),
+    std::make_pair("WM/CatalogNo", "CATALOGNUMBER"),
+    std::make_pair("WM/Barcode", "BARCODE"),
+    std::make_pair("WM/EncodedBy", "ENCODEDBY"),
+    std::make_pair("WM/AlbumSortOrder", "ALBUMSORT"),
+    std::make_pair("WM/AlbumArtistSortOrder", "ALBUMARTISTSORT"),
+    std::make_pair("WM/ArtistSortOrder", "ARTISTSORT"),
+    std::make_pair("WM/TitleSortOrder", "TITLESORT"),
+    std::make_pair("WM/Script", "SCRIPT"),
+    std::make_pair("WM/Language", "LANGUAGE"),
+    std::make_pair("WM/ARTISTS", "ARTISTS"),
+    std::make_pair("ASIN", "ASIN"),
+    std::make_pair("MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID"),
+    std::make_pair("MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID"),
+    std::make_pair("MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID"),
+    std::make_pair("MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID"),
+    std::make_pair("MusicBrainz/Album Release Country", "RELEASECOUNTRY"),
+    std::make_pair("MusicBrainz/Album Status", "RELEASESTATUS"),
+    std::make_pair("MusicBrainz/Album Type", "RELEASETYPE"),
+    std::make_pair("MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID"),
+    std::make_pair("MusicBrainz/Release Track Id", "MUSICBRAINZ_RELEASETRACKID"),
+    std::make_pair("MusicBrainz/Work Id", "MUSICBRAINZ_WORKID"),
+    std::make_pair("MusicIP/PUID", "MUSICIP_PUID"),
+    std::make_pair("Acoustid/Id", "ACOUSTID_ID"),
+    std::make_pair("Acoustid/Fingerprint", "ACOUSTID_FINGERPRINT"),
   };
   const size_t keyTranslationSize = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
 
   String translateKey(const String &key)
   {
     for(size_t i = 0; i < keyTranslationSize; ++i) {
-      if(key == keyTranslation[i][0])
-        return keyTranslation[i][1];
+      if(key == keyTranslation[i].first)
+        return keyTranslation[i].second;
     }
 
     return String();
@@ -322,9 +322,8 @@ PropertyMap ASF::Tag::setProperties(const PropertyMap &props)
 {
   static Map<String, String> reverseKeyMap;
   if(reverseKeyMap.isEmpty()) {
-    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
-    for(int i = 0; i < numKeys; i++) {
-      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
+    for(size_t i = 0; i < keyTranslationSize; i++) {
+      reverseKeyMap[keyTranslation[i].second] = keyTranslation[i].first;
     }
   }
 
diff --git a/taglib/mp4/mp4tag.cpp b/taglib/mp4/mp4tag.cpp
index ab106bf3..b821a440 100644
--- a/taglib/mp4/mp4tag.cpp
+++ b/taglib/mp4/mp4tag.cpp
@@ -871,84 +871,84 @@ bool MP4::Tag::contains(const String &key) const
 
 namespace
 {
-  const char *keyTranslation[][2] = {
-    { "\251nam", "TITLE" },
-    { "\251ART", "ARTIST" },
-    { "\251alb", "ALBUM" },
-    { "\251cmt", "COMMENT" },
-    { "\251gen", "GENRE" },
-    { "\251day", "DATE" },
-    { "\251wrt", "COMPOSER" },
-    { "\251grp", "GROUPING" },
-    { "aART", "ALBUMARTIST" },
-    { "trkn", "TRACKNUMBER" },
-    { "disk", "DISCNUMBER" },
-    { "cpil", "COMPILATION" },
-    { "tmpo", "BPM" },
-    { "cprt", "COPYRIGHT" },
-    { "\251lyr", "LYRICS" },
-    { "\251too", "ENCODEDBY" },
-    { "soal", "ALBUMSORT" },
-    { "soaa", "ALBUMARTISTSORT" },
-    { "soar", "ARTISTSORT" },
-    { "sonm", "TITLESORT" },
-    { "soco", "COMPOSERSORT" },
-    { "sosn", "SHOWSORT" },
-    { "shwm", "SHOWWORKMOVEMENT" },
-    { "pgap", "GAPLESSPLAYBACK" },
-    { "pcst", "PODCAST" },
-    { "catg", "PODCASTCATEGORY" },
-    { "desc", "PODCASTDESC" },
-    { "egid", "PODCASTID" },
-    { "purl", "PODCASTURL" },
-    { "tves", "TVEPISODE" },
-    { "tven", "TVEPISODEID" },
-    { "tvnn", "TVNETWORK" },
-    { "tvsn", "TVSEASON" },
-    { "tvsh", "TVSHOW" },
-    { "\251wrk", "WORK" },
-    { "\251mvn", "MOVEMENTNAME" },
-    { "\251mvi", "MOVEMENTNUMBER" },
-    { "\251mvc", "MOVEMENTCOUNT" },
-    { "----:com.apple.iTunes:MusicBrainz Track Id", "MUSICBRAINZ_TRACKID" },
-    { "----:com.apple.iTunes:MusicBrainz Artist Id", "MUSICBRAINZ_ARTISTID" },
-    { "----:com.apple.iTunes:MusicBrainz Album Id", "MUSICBRAINZ_ALBUMID" },
-    { "----:com.apple.iTunes:MusicBrainz Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
-    { "----:com.apple.iTunes:MusicBrainz Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
-    { "----:com.apple.iTunes:MusicBrainz Release Track Id", "MUSICBRAINZ_RELEASETRACKID" },
-    { "----:com.apple.iTunes:MusicBrainz Work Id", "MUSICBRAINZ_WORKID" },
-    { "----:com.apple.iTunes:MusicBrainz Album Release Country", "RELEASECOUNTRY" },
-    { "----:com.apple.iTunes:MusicBrainz Album Status", "RELEASESTATUS" },
-    { "----:com.apple.iTunes:MusicBrainz Album Type", "RELEASETYPE" },
-    { "----:com.apple.iTunes:ARTISTS", "ARTISTS" },
-    { "----:com.apple.iTunes:originaldate", "ORIGINALDATE" },
-    { "----:com.apple.iTunes:ASIN", "ASIN" },
-    { "----:com.apple.iTunes:LABEL", "LABEL" },
-    { "----:com.apple.iTunes:LYRICIST", "LYRICIST" },
-    { "----:com.apple.iTunes:CONDUCTOR", "CONDUCTOR" },
-    { "----:com.apple.iTunes:REMIXER", "REMIXER" },
-    { "----:com.apple.iTunes:ENGINEER", "ENGINEER" },
-    { "----:com.apple.iTunes:PRODUCER", "PRODUCER" },
-    { "----:com.apple.iTunes:DJMIXER", "DJMIXER" },
-    { "----:com.apple.iTunes:MIXER", "MIXER" },
-    { "----:com.apple.iTunes:SUBTITLE", "SUBTITLE" },
-    { "----:com.apple.iTunes:DISCSUBTITLE", "DISCSUBTITLE" },
-    { "----:com.apple.iTunes:MOOD", "MOOD" },
-    { "----:com.apple.iTunes:ISRC", "ISRC" },
-    { "----:com.apple.iTunes:CATALOGNUMBER", "CATALOGNUMBER" },
-    { "----:com.apple.iTunes:BARCODE", "BARCODE" },
-    { "----:com.apple.iTunes:SCRIPT", "SCRIPT" },
-    { "----:com.apple.iTunes:LANGUAGE", "LANGUAGE" },
-    { "----:com.apple.iTunes:LICENSE", "LICENSE" },
-    { "----:com.apple.iTunes:MEDIA", "MEDIA" },
+  const std::pair<const char *, const char *> keyTranslation[] = {
+    std::make_pair("\251nam", "TITLE"),
+    std::make_pair("\251ART", "ARTIST"),
+    std::make_pair("\251alb", "ALBUM"),
+    std::make_pair("\251cmt", "COMMENT"),
+    std::make_pair("\251gen", "GENRE"),
+    std::make_pair("\251day", "DATE"),
+    std::make_pair("\251wrt", "COMPOSER"),
+    std::make_pair("\251grp", "GROUPING"),
+    std::make_pair("aART", "ALBUMARTIST"),
+    std::make_pair("trkn", "TRACKNUMBER"),
+    std::make_pair("disk", "DISCNUMBER"),
+    std::make_pair("cpil", "COMPILATION"),
+    std::make_pair("tmpo", "BPM"),
+    std::make_pair("cprt", "COPYRIGHT"),
+    std::make_pair("\251lyr", "LYRICS"),
+    std::make_pair("\251too", "ENCODEDBY"),
+    std::make_pair("soal", "ALBUMSORT"),
+    std::make_pair("soaa", "ALBUMARTISTSORT"),
+    std::make_pair("soar", "ARTISTSORT"),
+    std::make_pair("sonm", "TITLESORT"),
+    std::make_pair("soco", "COMPOSERSORT"),
+    std::make_pair("sosn", "SHOWSORT"),
+    std::make_pair("shwm", "SHOWWORKMOVEMENT"),
+    std::make_pair("pgap", "GAPLESSPLAYBACK"),
+    std::make_pair("pcst", "PODCAST"),
+    std::make_pair("catg", "PODCASTCATEGORY"),
+    std::make_pair("desc", "PODCASTDESC"),
+    std::make_pair("egid", "PODCASTID"),
+    std::make_pair("purl", "PODCASTURL"),
+    std::make_pair("tves", "TVEPISODE"),
+    std::make_pair("tven", "TVEPISODEID"),
+    std::make_pair("tvnn", "TVNETWORK"),
+    std::make_pair("tvsn", "TVSEASON"),
+    std::make_pair("tvsh", "TVSHOW"),
+    std::make_pair("\251wrk", "WORK"),
+    std::make_pair("\251mvn", "MOVEMENTNAME"),
+    std::make_pair("\251mvi", "MOVEMENTNUMBER"),
+    std::make_pair("\251mvc", "MOVEMENTCOUNT"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Track Id", "MUSICBRAINZ_TRACKID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Artist Id", "MUSICBRAINZ_ARTISTID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Album Id", "MUSICBRAINZ_ALBUMID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Release Group Id", "MUSICBRAINZ_RELEASEGROUPID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Release Track Id", "MUSICBRAINZ_RELEASETRACKID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Work Id", "MUSICBRAINZ_WORKID"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Album Release Country", "RELEASECOUNTRY"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Album Status", "RELEASESTATUS"),
+    std::make_pair("----:com.apple.iTunes:MusicBrainz Album Type", "RELEASETYPE"),
+    std::make_pair("----:com.apple.iTunes:ARTISTS", "ARTISTS"),
+    std::make_pair("----:com.apple.iTunes:originaldate", "ORIGINALDATE"),
+    std::make_pair("----:com.apple.iTunes:ASIN", "ASIN"),
+    std::make_pair("----:com.apple.iTunes:LABEL", "LABEL"),
+    std::make_pair("----:com.apple.iTunes:LYRICIST", "LYRICIST"),
+    std::make_pair("----:com.apple.iTunes:CONDUCTOR", "CONDUCTOR"),
+    std::make_pair("----:com.apple.iTunes:REMIXER", "REMIXER"),
+    std::make_pair("----:com.apple.iTunes:ENGINEER", "ENGINEER"),
+    std::make_pair("----:com.apple.iTunes:PRODUCER", "PRODUCER"),
+    std::make_pair("----:com.apple.iTunes:DJMIXER", "DJMIXER"),
+    std::make_pair("----:com.apple.iTunes:MIXER", "MIXER"),
+    std::make_pair("----:com.apple.iTunes:SUBTITLE", "SUBTITLE"),
+    std::make_pair("----:com.apple.iTunes:DISCSUBTITLE", "DISCSUBTITLE"),
+    std::make_pair("----:com.apple.iTunes:MOOD", "MOOD"),
+    std::make_pair("----:com.apple.iTunes:ISRC", "ISRC"),
+    std::make_pair("----:com.apple.iTunes:CATALOGNUMBER", "CATALOGNUMBER"),
+    std::make_pair("----:com.apple.iTunes:BARCODE", "BARCODE"),
+    std::make_pair("----:com.apple.iTunes:SCRIPT", "SCRIPT"),
+    std::make_pair("----:com.apple.iTunes:LANGUAGE", "LANGUAGE"),
+    std::make_pair("----:com.apple.iTunes:LICENSE", "LICENSE"),
+    std::make_pair("----:com.apple.iTunes:MEDIA", "MEDIA"),
   };
   const size_t keyTranslationSize = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
 
   String translateKey(const String &key)
   {
     for(size_t i = 0; i < keyTranslationSize; ++i) {
-      if(key == keyTranslation[i][0])
-        return keyTranslation[i][1];
+      if(key == keyTranslation[i].first)
+        return keyTranslation[i].second;
     }
 
     return String();
@@ -998,9 +998,8 @@ PropertyMap MP4::Tag::setProperties(const PropertyMap &props)
 {
   static Map<String, String> reverseKeyMap;
   if(reverseKeyMap.isEmpty()) {
-    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
-    for(int i = 0; i < numKeys; i++) {
-      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
+    for(size_t i = 0; i < keyTranslationSize; i++) {
+      reverseKeyMap[keyTranslation[i].second] = keyTranslation[i].first;
     }
   }
 
diff --git a/taglib/mpeg/id3v2/frames/textidentificationframe.cpp b/taglib/mpeg/id3v2/frames/textidentificationframe.cpp
index af161f27..bc647b54 100644
--- a/taglib/mpeg/id3v2/frames/textidentificationframe.cpp
+++ b/taglib/mpeg/id3v2/frames/textidentificationframe.cpp
@@ -125,12 +125,12 @@ void TextIdentificationFrame::setTextEncoding(String::Type encoding)
 namespace
 {
   // array of allowed TIPL prefixes and their corresponding key value
-  const char* involvedPeople[][2] = {
-      {"ARRANGER", "ARRANGER"},
-      {"ENGINEER", "ENGINEER"},
-      {"PRODUCER", "PRODUCER"},
-      {"DJ-MIX", "DJMIXER"},
-      {"MIX", "MIXER"},
+  const std::pair<const char *, const char *> involvedPeople[] = {
+      std::make_pair("ARRANGER", "ARRANGER"),
+      std::make_pair("ENGINEER", "ENGINEER"),
+      std::make_pair("PRODUCER", "PRODUCER"),
+      std::make_pair("DJ-MIX", "DJMIXER"),
+      std::make_pair("MIX", "MIXER"),
   };
   const size_t involvedPeopleSize = sizeof(involvedPeople) / sizeof(involvedPeople[0]);
 }  // namespace
@@ -140,7 +140,7 @@ const KeyConversionMap &TextIdentificationFrame::involvedPeopleMap() // static
   static KeyConversionMap m;
   if(m.isEmpty()) {
     for(size_t i = 0; i < involvedPeopleSize; ++i)
-      m.insert(involvedPeople[i][1], involvedPeople[i][0]);
+      m.insert(involvedPeople[i].second, involvedPeople[i].first);
   }
   return m;
 }
@@ -274,8 +274,8 @@ PropertyMap TextIdentificationFrame::makeTIPLProperties() const
   for(StringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
     bool found = false;
     for(size_t i = 0; i < involvedPeopleSize; ++i)
-      if(*it == involvedPeople[i][0]) {
-        map.insert(involvedPeople[i][1], (++it)->split(","));
+      if(*it == involvedPeople[i].first) {
+        map.insert(involvedPeople[i].second, (++it)->split(","));
         found = true;
         break;
       }
diff --git a/taglib/mpeg/id3v2/id3v2frame.cpp b/taglib/mpeg/id3v2/id3v2frame.cpp
index f8abcbbf..6d34f1cd 100644
--- a/taglib/mpeg/id3v2/id3v2frame.cpp
+++ b/taglib/mpeg/id3v2/id3v2frame.cpp
@@ -321,104 +321,104 @@ String::Type Frame::checkTextEncoding(const StringList &fields, String::Type enc
 
 namespace
 {
-  const char *frameTranslation[][2] = {
+  const std::pair<const char *, const char *> frameTranslation[] = {
     // Text information frames
-    { "TALB", "ALBUM"},
-    { "TBPM", "BPM" },
-    { "TCOM", "COMPOSER" },
-    { "TCON", "GENRE" },
-    { "TCOP", "COPYRIGHT" },
-    { "TDEN", "ENCODINGTIME" },
-    { "TDLY", "PLAYLISTDELAY" },
-    { "TDOR", "ORIGINALDATE" },
-    { "TDRC", "DATE" },
-    // { "TRDA", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
-    // { "TDAT", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
-    // { "TYER", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
-    // { "TIME", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
-    { "TDRL", "RELEASEDATE" },
-    { "TDTG", "TAGGINGDATE" },
-    { "TENC", "ENCODEDBY" },
-    { "TEXT", "LYRICIST" },
-    { "TFLT", "FILETYPE" },
-    //{ "TIPL", "INVOLVEDPEOPLE" }, handled separately
-    { "TIT1", "CONTENTGROUP" }, // 'Work' in iTunes
-    { "TIT2", "TITLE"},
-    { "TIT3", "SUBTITLE" },
-    { "TKEY", "INITIALKEY" },
-    { "TLAN", "LANGUAGE" },
-    { "TLEN", "LENGTH" },
-    //{ "TMCL", "MUSICIANCREDITS" }, handled separately
-    { "TMED", "MEDIA" },
-    { "TMOO", "MOOD" },
-    { "TOAL", "ORIGINALALBUM" },
-    { "TOFN", "ORIGINALFILENAME" },
-    { "TOLY", "ORIGINALLYRICIST" },
-    { "TOPE", "ORIGINALARTIST" },
-    { "TOWN", "OWNER" },
-    { "TPE1", "ARTIST"},
-    { "TPE2", "ALBUMARTIST" }, // id3's spec says 'PERFORMER', but most programs use 'ALBUMARTIST'
-    { "TPE3", "CONDUCTOR" },
-    { "TPE4", "REMIXER" }, // could also be ARRANGER
-    { "TPOS", "DISCNUMBER" },
-    { "TPRO", "PRODUCEDNOTICE" },
-    { "TPUB", "LABEL" },
-    { "TRCK", "TRACKNUMBER" },
-    { "TRSN", "RADIOSTATION" },
-    { "TRSO", "RADIOSTATIONOWNER" },
-    { "TSOA", "ALBUMSORT" },
-    { "TSOC", "COMPOSERSORT" },
-    { "TSOP", "ARTISTSORT" },
-    { "TSOT", "TITLESORT" },
-    { "TSO2", "ALBUMARTISTSORT" }, // non-standard, used by iTunes
-    { "TSRC", "ISRC" },
-    { "TSSE", "ENCODING" },
+    std::make_pair("TALB", "ALBUM"),
+    std::make_pair("TBPM", "BPM"),
+    std::make_pair("TCOM", "COMPOSER"),
+    std::make_pair("TCON", "GENRE"),
+    std::make_pair("TCOP", "COPYRIGHT"),
+    std::make_pair("TDEN", "ENCODINGTIME"),
+    std::make_pair("TDLY", "PLAYLISTDELAY"),
+    std::make_pair("TDOR", "ORIGINALDATE"),
+    std::make_pair("TDRC", "DATE"),
+    // std::make_pair("TRDA", "DATE"), // id3 v2.3, replaced by TDRC in v2.4
+    // std::make_pair("TDAT", "DATE"), // id3 v2.3, replaced by TDRC in v2.4
+    // std::make_pair("TYER", "DATE"), // id3 v2.3, replaced by TDRC in v2.4
+    // std::make_pair("TIME", "DATE"), // id3 v2.3, replaced by TDRC in v2.4
+    std::make_pair("TDRL", "RELEASEDATE"),
+    std::make_pair("TDTG", "TAGGINGDATE"),
+    std::make_pair("TENC", "ENCODEDBY"),
+    std::make_pair("TEXT", "LYRICIST"),
+    std::make_pair("TFLT", "FILETYPE"),
+    //std::make_pair("TIPL", "INVOLVEDPEOPLE"), handled separately
+    std::make_pair("TIT1", "CONTENTGROUP"), // 'Work' in iTunes
+    std::make_pair("TIT2", "TITLE"),
+    std::make_pair("TIT3", "SUBTITLE"),
+    std::make_pair("TKEY", "INITIALKEY"),
+    std::make_pair("TLAN", "LANGUAGE"),
+    std::make_pair("TLEN", "LENGTH"),
+    //std::make_pair("TMCL", "MUSICIANCREDITS"), handled separately
+    std::make_pair("TMED", "MEDIA"),
+    std::make_pair("TMOO", "MOOD"),
+    std::make_pair("TOAL", "ORIGINALALBUM"),
+    std::make_pair("TOFN", "ORIGINALFILENAME"),
+    std::make_pair("TOLY", "ORIGINALLYRICIST"),
+    std::make_pair("TOPE", "ORIGINALARTIST"),
+    std::make_pair("TOWN", "OWNER"),
+    std::make_pair("TPE1", "ARTIST"),
+    std::make_pair("TPE2", "ALBUMARTIST"), // id3's spec says 'PERFORMER', but most programs use 'ALBUMARTIST'
+    std::make_pair("TPE3", "CONDUCTOR"),
+    std::make_pair("TPE4", "REMIXER"), // could also be ARRANGER
+    std::make_pair("TPOS", "DISCNUMBER"),
+    std::make_pair("TPRO", "PRODUCEDNOTICE"),
+    std::make_pair("TPUB", "LABEL"),
+    std::make_pair("TRCK", "TRACKNUMBER"),
+    std::make_pair("TRSN", "RADIOSTATION"),
+    std::make_pair("TRSO", "RADIOSTATIONOWNER"),
+    std::make_pair("TSOA", "ALBUMSORT"),
+    std::make_pair("TSOC", "COMPOSERSORT"),
+    std::make_pair("TSOP", "ARTISTSORT"),
+    std::make_pair("TSOT", "TITLESORT"),
+    std::make_pair("TSO2", "ALBUMARTISTSORT"), // non-standard, used by iTunes
+    std::make_pair("TSRC", "ISRC"),
+    std::make_pair("TSSE", "ENCODING"),
     // URL frames
-    { "WCOP", "COPYRIGHTURL" },
-    { "WOAF", "FILEWEBPAGE" },
-    { "WOAR", "ARTISTWEBPAGE" },
-    { "WOAS", "AUDIOSOURCEWEBPAGE" },
-    { "WORS", "RADIOSTATIONWEBPAGE" },
-    { "WPAY", "PAYMENTWEBPAGE" },
-    { "WPUB", "PUBLISHERWEBPAGE" },
-    //{ "WXXX", "URL"}, handled specially
+    std::make_pair("WCOP", "COPYRIGHTURL"),
+    std::make_pair("WOAF", "FILEWEBPAGE"),
+    std::make_pair("WOAR", "ARTISTWEBPAGE"),
+    std::make_pair("WOAS", "AUDIOSOURCEWEBPAGE"),
+    std::make_pair("WORS", "RADIOSTATIONWEBPAGE"),
+    std::make_pair("WPAY", "PAYMENTWEBPAGE"),
+    std::make_pair("WPUB", "PUBLISHERWEBPAGE"),
+    //std::make_pair("WXXX", "URL"), handled specially
     // Other frames
-    { "COMM", "COMMENT" },
-    //{ "USLT", "LYRICS" }, handled specially
+    std::make_pair("COMM", "COMMENT"),
+    //std::make_pair("USLT", "LYRICS"), handled specially
     // Apple iTunes proprietary frames
-    { "PCST", "PODCAST" },
-    { "TCAT", "PODCASTCATEGORY" },
-    { "TDES", "PODCASTDESC" },
-    { "TGID", "PODCASTID" },
-    { "WFED", "PODCASTURL" },
-    { "MVNM", "MOVEMENTNAME" },
-    { "MVIN", "MOVEMENTNUMBER" },
-    { "GRP1", "GROUPING" },
+    std::make_pair("PCST", "PODCAST"),
+    std::make_pair("TCAT", "PODCASTCATEGORY"),
+    std::make_pair("TDES", "PODCASTDESC"),
+    std::make_pair("TGID", "PODCASTID"),
+    std::make_pair("WFED", "PODCASTURL"),
+    std::make_pair("MVNM", "MOVEMENTNAME"),
+    std::make_pair("MVIN", "MOVEMENTNUMBER"),
+    std::make_pair("GRP1", "GROUPING"),
   };
   const size_t frameTranslationSize = sizeof(frameTranslation) / sizeof(frameTranslation[0]);
 
-  const char *txxxFrameTranslation[][2] = {
-    { "MUSICBRAINZ ALBUM ID",         "MUSICBRAINZ_ALBUMID" },
-    { "MUSICBRAINZ ARTIST ID",        "MUSICBRAINZ_ARTISTID" },
-    { "MUSICBRAINZ ALBUM ARTIST ID",  "MUSICBRAINZ_ALBUMARTISTID" },
-    { "MUSICBRAINZ ALBUM RELEASE COUNTRY", "RELEASECOUNTRY" },
-    { "MUSICBRAINZ ALBUM STATUS", "RELEASESTATUS" },
-    { "MUSICBRAINZ ALBUM TYPE", "RELEASETYPE" },
-    { "MUSICBRAINZ RELEASE GROUP ID", "MUSICBRAINZ_RELEASEGROUPID" },
-    { "MUSICBRAINZ RELEASE TRACK ID", "MUSICBRAINZ_RELEASETRACKID" },
-    { "MUSICBRAINZ WORK ID",          "MUSICBRAINZ_WORKID" },
-    { "ACOUSTID ID",                  "ACOUSTID_ID" },
-    { "ACOUSTID FINGERPRINT",         "ACOUSTID_FINGERPRINT" },
-    { "MUSICIP PUID",                 "MUSICIP_PUID" },
+  const std::pair<const char *, const char *> txxxFrameTranslation[] = {
+    std::make_pair("MUSICBRAINZ ALBUM ID",         "MUSICBRAINZ_ALBUMID"),
+    std::make_pair("MUSICBRAINZ ARTIST ID",        "MUSICBRAINZ_ARTISTID"),
+    std::make_pair("MUSICBRAINZ ALBUM ARTIST ID",  "MUSICBRAINZ_ALBUMARTISTID"),
+    std::make_pair("MUSICBRAINZ ALBUM RELEASE COUNTRY", "RELEASECOUNTRY"),
+    std::make_pair("MUSICBRAINZ ALBUM STATUS",     "RELEASESTATUS"),
+    std::make_pair("MUSICBRAINZ ALBUM TYPE",       "RELEASETYPE"),
+    std::make_pair("MUSICBRAINZ RELEASE GROUP ID", "MUSICBRAINZ_RELEASEGROUPID"),
+    std::make_pair("MUSICBRAINZ RELEASE TRACK ID", "MUSICBRAINZ_RELEASETRACKID"),
+    std::make_pair("MUSICBRAINZ WORK ID",          "MUSICBRAINZ_WORKID"),
+    std::make_pair("ACOUSTID ID",                  "ACOUSTID_ID"),
+    std::make_pair("ACOUSTID FINGERPRINT",         "ACOUSTID_FINGERPRINT"),
+    std::make_pair("MUSICIP PUID",                 "MUSICIP_PUID"),
   };
   const size_t txxxFrameTranslationSize = sizeof(txxxFrameTranslation) / sizeof(txxxFrameTranslation[0]);
 
   // list of deprecated frames and their successors
-  const char *deprecatedFrames[][2] = {
-    {"TRDA", "TDRC"}, // 2.3 -> 2.4 (http://en.wikipedia.org/wiki/ID3)
-    {"TDAT", "TDRC"}, // 2.3 -> 2.4
-    {"TYER", "TDRC"}, // 2.3 -> 2.4
-    {"TIME", "TDRC"}, // 2.3 -> 2.4
+  const std::pair<const char *, const char *> deprecatedFrames[] = {
+    std::make_pair("TRDA", "TDRC"), // 2.3 -> 2.4 (http://en.wikipedia.org/wiki/ID3)
+    std::make_pair("TDAT", "TDRC"), // 2.3 -> 2.4
+    std::make_pair("TYER", "TDRC"), // 2.3 -> 2.4
+    std::make_pair("TIME", "TDRC"), // 2.3 -> 2.4
   };
   const size_t deprecatedFramesSize = sizeof(deprecatedFrames) / sizeof(deprecatedFrames[0]);
 }  // namespace
@@ -427,14 +427,14 @@ String Frame::frameIDToKey(const ByteVector &id)
 {
   ByteVector id24 = id;
   for(size_t i = 0; i < deprecatedFramesSize; ++i) {
-    if(id24 == deprecatedFrames[i][0]) {
-      id24 = deprecatedFrames[i][1];
+    if(id24 == deprecatedFrames[i].first) {
+      id24 = deprecatedFrames[i].second;
       break;
     }
   }
   for(size_t i = 0; i < frameTranslationSize; ++i) {
-    if(id24 == frameTranslation[i][0])
-      return frameTranslation[i][1];
+    if(id24 == frameTranslation[i].first)
+      return frameTranslation[i].second;
   }
   return String();
 }
@@ -443,8 +443,8 @@ ByteVector Frame::keyToFrameID(const String &s)
 {
   const String key = s.upper();
   for(size_t i = 0; i < frameTranslationSize; ++i) {
-    if(key == frameTranslation[i][1])
-      return frameTranslation[i][0];
+    if(key == frameTranslation[i].second)
+      return frameTranslation[i].first;
   }
   return ByteVector();
 }
@@ -453,8 +453,8 @@ String Frame::txxxToKey(const String &description)
 {
   const String d = description.upper();
   for(size_t i = 0; i < txxxFrameTranslationSize; ++i) {
-    if(d == txxxFrameTranslation[i][0])
-      return txxxFrameTranslation[i][1];
+    if(d == txxxFrameTranslation[i].first)
+      return txxxFrameTranslation[i].second;
   }
   return d;
 }
@@ -463,8 +463,8 @@ String Frame::keyToTXXX(const String &s)
 {
   const String key = s.upper();
   for(size_t i = 0; i < txxxFrameTranslationSize; ++i) {
-    if(key == txxxFrameTranslation[i][1])
-      return txxxFrameTranslation[i][0];
+    if(key == txxxFrameTranslation[i].second)
+      return txxxFrameTranslation[i].first;
   }
   return s;
 }
diff --git a/taglib/mpeg/id3v2/id3v2framefactory.cpp b/taglib/mpeg/id3v2/id3v2framefactory.cpp
index 9ab113fa..1173cff8 100644
--- a/taglib/mpeg/id3v2/id3v2framefactory.cpp
+++ b/taglib/mpeg/id3v2/id3v2framefactory.cpp
@@ -392,87 +392,87 @@ FrameFactory::~FrameFactory()
 namespace
 {
   // Frame conversion table ID3v2.2 -> 2.4
-  const char *frameConversion2[][2] = {
-    { "BUF", "RBUF" },
-    { "CNT", "PCNT" },
-    { "COM", "COMM" },
-    { "CRA", "AENC" },
-    { "ETC", "ETCO" },
-    { "GEO", "GEOB" },
-    { "IPL", "TIPL" },
-    { "MCI", "MCDI" },
-    { "MLL", "MLLT" },
-    { "POP", "POPM" },
-    { "REV", "RVRB" },
-    { "SLT", "SYLT" },
-    { "STC", "SYTC" },
-    { "TAL", "TALB" },
-    { "TBP", "TBPM" },
-    { "TCM", "TCOM" },
-    { "TCO", "TCON" },
-    { "TCP", "TCMP" },
-    { "TCR", "TCOP" },
-    { "TDY", "TDLY" },
-    { "TEN", "TENC" },
-    { "TFT", "TFLT" },
-    { "TKE", "TKEY" },
-    { "TLA", "TLAN" },
-    { "TLE", "TLEN" },
-    { "TMT", "TMED" },
-    { "TOA", "TOAL" },
-    { "TOF", "TOFN" },
-    { "TOL", "TOLY" },
-    { "TOR", "TDOR" },
-    { "TOT", "TOAL" },
-    { "TP1", "TPE1" },
-    { "TP2", "TPE2" },
-    { "TP3", "TPE3" },
-    { "TP4", "TPE4" },
-    { "TPA", "TPOS" },
-    { "TPB", "TPUB" },
-    { "TRC", "TSRC" },
-    { "TRD", "TDRC" },
-    { "TRK", "TRCK" },
-    { "TS2", "TSO2" },
-    { "TSA", "TSOA" },
-    { "TSC", "TSOC" },
-    { "TSP", "TSOP" },
-    { "TSS", "TSSE" },
-    { "TST", "TSOT" },
-    { "TT1", "TIT1" },
-    { "TT2", "TIT2" },
-    { "TT3", "TIT3" },
-    { "TXT", "TOLY" },
-    { "TXX", "TXXX" },
-    { "TYE", "TDRC" },
-    { "UFI", "UFID" },
-    { "ULT", "USLT" },
-    { "WAF", "WOAF" },
-    { "WAR", "WOAR" },
-    { "WAS", "WOAS" },
-    { "WCM", "WCOM" },
-    { "WCP", "WCOP" },
-    { "WPB", "WPUB" },
-    { "WXX", "WXXX" },
+  const std::pair<const char *, const char *> frameConversion2[] = {
+    std::make_pair("BUF", "RBUF"),
+    std::make_pair("CNT", "PCNT"),
+    std::make_pair("COM", "COMM"),
+    std::make_pair("CRA", "AENC"),
+    std::make_pair("ETC", "ETCO"),
+    std::make_pair("GEO", "GEOB"),
+    std::make_pair("IPL", "TIPL"),
+    std::make_pair("MCI", "MCDI"),
+    std::make_pair("MLL", "MLLT"),
+    std::make_pair("POP", "POPM"),
+    std::make_pair("REV", "RVRB"),
+    std::make_pair("SLT", "SYLT"),
+    std::make_pair("STC", "SYTC"),
+    std::make_pair("TAL", "TALB"),
+    std::make_pair("TBP", "TBPM"),
+    std::make_pair("TCM", "TCOM"),
+    std::make_pair("TCO", "TCON"),
+    std::make_pair("TCP", "TCMP"),
+    std::make_pair("TCR", "TCOP"),
+    std::make_pair("TDY", "TDLY"),
+    std::make_pair("TEN", "TENC"),
+    std::make_pair("TFT", "TFLT"),
+    std::make_pair("TKE", "TKEY"),
+    std::make_pair("TLA", "TLAN"),
+    std::make_pair("TLE", "TLEN"),
+    std::make_pair("TMT", "TMED"),
+    std::make_pair("TOA", "TOAL"),
+    std::make_pair("TOF", "TOFN"),
+    std::make_pair("TOL", "TOLY"),
+    std::make_pair("TOR", "TDOR"),
+    std::make_pair("TOT", "TOAL"),
+    std::make_pair("TP1", "TPE1"),
+    std::make_pair("TP2", "TPE2"),
+    std::make_pair("TP3", "TPE3"),
+    std::make_pair("TP4", "TPE4"),
+    std::make_pair("TPA", "TPOS"),
+    std::make_pair("TPB", "TPUB"),
+    std::make_pair("TRC", "TSRC"),
+    std::make_pair("TRD", "TDRC"),
+    std::make_pair("TRK", "TRCK"),
+    std::make_pair("TS2", "TSO2"),
+    std::make_pair("TSA", "TSOA"),
+    std::make_pair("TSC", "TSOC"),
+    std::make_pair("TSP", "TSOP"),
+    std::make_pair("TSS", "TSSE"),
+    std::make_pair("TST", "TSOT"),
+    std::make_pair("TT1", "TIT1"),
+    std::make_pair("TT2", "TIT2"),
+    std::make_pair("TT3", "TIT3"),
+    std::make_pair("TXT", "TOLY"),
+    std::make_pair("TXX", "TXXX"),
+    std::make_pair("TYE", "TDRC"),
+    std::make_pair("UFI", "UFID"),
+    std::make_pair("ULT", "USLT"),
+    std::make_pair("WAF", "WOAF"),
+    std::make_pair("WAR", "WOAR"),
+    std::make_pair("WAS", "WOAS"),
+    std::make_pair("WCM", "WCOM"),
+    std::make_pair("WCP", "WCOP"),
+    std::make_pair("WPB", "WPUB"),
+    std::make_pair("WXX", "WXXX"),
 
     // Apple iTunes nonstandard frames
-    { "PCS", "PCST" },
-    { "TCT", "TCAT" },
-    { "TDR", "TDRL" },
-    { "TDS", "TDES" },
-    { "TID", "TGID" },
-    { "WFD", "WFED" },
-    { "MVN", "MVNM" },
-    { "MVI", "MVIN" },
-    { "GP1", "GRP1" },
+    std::make_pair("PCS", "PCST"),
+    std::make_pair("TCT", "TCAT"),
+    std::make_pair("TDR", "TDRL"),
+    std::make_pair("TDS", "TDES"),
+    std::make_pair("TID", "TGID"),
+    std::make_pair("WFD", "WFED"),
+    std::make_pair("MVN", "MVNM"),
+    std::make_pair("MVI", "MVIN"),
+    std::make_pair("GP1", "GRP1"),
   };
   const size_t frameConversion2Size = sizeof(frameConversion2) / sizeof(frameConversion2[0]);
 
   // Frame conversion table ID3v2.3 -> 2.4
-  const char *frameConversion3[][2] = {
-    { "TORY", "TDOR" },
-    { "TYER", "TDRC" },
-    { "IPLS", "TIPL" },
+  const std::pair<const char *, const char *> frameConversion3[] = {
+    std::make_pair("TORY", "TDOR"),
+    std::make_pair("TYER", "TDRC"),
+    std::make_pair("IPLS", "TIPL"),
   };
   const size_t frameConversion3Size = sizeof(frameConversion3) / sizeof(frameConversion3[0]);
 }  // namespace
@@ -502,8 +502,8 @@ bool FrameFactory::updateFrame(Frame::Header *header) const
     // the frames to their 4 byte ID3v2.4 equivalent.
 
     for(size_t i = 0; i < frameConversion2Size; ++i) {
-      if(frameID == frameConversion2[i][0]) {
-        header->setFrameID(frameConversion2[i][1]);
+      if(frameID == frameConversion2[i].first) {
+        header->setFrameID(frameConversion2[i].second);
         break;
       }
     }
@@ -526,8 +526,8 @@ bool FrameFactory::updateFrame(Frame::Header *header) const
     }
 
     for(size_t i = 0; i < frameConversion3Size; ++i) {
-      if(frameID == frameConversion3[i][0]) {
-        header->setFrameID(frameConversion3[i][1]);
+      if(frameID == frameConversion3[i].first) {
+        header->setFrameID(frameConversion3[i].second);
         break;
       }
     }