Generic numerical systems conversion
Instead of trying to create your own versions, you could try doing it without.

Not wanting to use ASCII conversions makes sense since that would be inefficient.  using a string to get the char value from a specific integer value, works well.  However, to go the other way a map would work better, and ignores how the native mapping works.

map&lt;char,int&gt; values = 
{
    {'0',0},
    {'1',1},
    {'2',2},
    {'3',3},
    {'4',4},
    {'5',5},
    {'6',6},
    {'7',7},
    {'8',8},
    {'9',9},
    {'A',10},
    {'B',11},
    {'C',12},
    {'D',13},
    {'E',14},
    {'F',15},
    {'G',16},
    {'H',17},
    {'I',18},
    {'J',19},
    {'K',20},
    {'L',21},
    {'M',22},
    {'N',23},
    {'O',24},
    {'P',25},
    {'Q',26},
    {'R',27},
    {'S',28},
    {'T',29},
    {'U',30},
    {'V',31},
    {'W',32},
    {'X',33},
    {'Y',34},
    {'Z',35}
};


Using a power function  reiterates over the same loop over and over again each time you call it.  It would make more sense to start at the end of the string and increase a multiplier in each iteration of the existing loop.  Also when working with base 10 it is alot simpler to keep the values as integers:

int ToBase10(string value, int base)
{
    int decValue = 0;
    int baseMult = 1;
    for (int i = value.size()-1; i &gt; -1; i--)
    {
        decValue += values[value[i]] * baseMult;
        baseMult *= base;
    }
    return decValue;
}


Since decimal has other meanings, it would be clearer to say base10 instead.

Lastly wrapping your functions up in a static class allows you to expose only what needs to exposed.  Also this keeps the validation in only one place:

#include &lt;map&gt;
using std::map;
using std::string;
class BaseConverter
{
    static map&lt;char, int&gt; values;
    static bool GoodValue(string&amp; value, int base);
    static string FromBase10(int value, int base);
    static int ToBase10(string value, int base);
public:
    static string Converter(string value, int fromBase, int toBase);
    static string Converter(int decValue, int base);
};

map&lt;char,int&gt; BaseConverter::values = 
{
    {'0',0},
    {'1',1},
    {'2',2},
    {'3',3},
    {'4',4},
    {'5',5},
    {'6',6},
    {'7',7},
    {'8',8},
    {'9',9},
    {'A',10},
    {'B',11},
    {'C',12},
    {'D',13},
    {'E',14},
    {'F',15},
    {'G',16},
    {'H',17},
    {'I',18},
    {'J',19},
    {'K',20},
    {'L',21},
    {'M',22},
    {'N',23},
    {'O',24},
    {'P',25},
    {'Q',26},
    {'R',27},
    {'S',28},
    {'T',29},
    {'U',30},
    {'V',31},
    {'W',32},
    {'X',33},
    {'Y',34},
    {'Z',35}
};

string BaseConverter::Converter(string value, int fromBase, int toBase)
{
    if(!GoodValue(value,fromBase))
    {
        return "Improper Value";
    }
    if (fromBase == toBase)
    {
        return value;
    }
    return FromBase10(ToBase10(value,fromBase),toBase);
}
string BaseConverter::Converter(int decValue, int base)
{
    return FromBase10(decValue,base);
} 



bool BaseConverter::GoodValue(string&amp; value, int base)
{
    for(int i = 0; i &lt; value.length();i++)
    {
        value[i] = toupper(value[i]);
        if (values[value[i]]&gt;= base)
        {
            return false;
        }   
    }
    return true;
}

string BaseConverter::FromBase10(int value, int base)
{
    const string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    string baseValue = "";
    while (value &gt; 0)
    {
        baseValue.insert(baseValue.begin(), chars[value % base]);
        value /= base;
    }
    return baseValue;
}

int BaseConverter::ToBase10(string value, int base)
{
    int decValue = 0;
    int baseMult = 1;
    for (int i = value.size()-1; i &gt; -1; i--)
    {
        decValue += values[value[i]] * baseMult;
        baseMult *= base;
    }
    return decValue;
}


Notice the simplicity of only having to call one wrapper function(string test = BaseConverter::Converter("291", 10, 16);)