使用“long long”而不是“int”，这样它适用于更大的数字。这里是优雅的解决方案。

long long ChardToint(char *arr, size_t len){
   
int toptenf=1;
long long toptenLf=10000000LL;
long long makeintf=3000000000000;
 
   
  makeintf= 0LL;


   int holdNumberf=0;
for(int i=len-1;i>=0 ;i--){
 switch(arr[i]){
      case '0':
      holdNumberf=0;
      break;
      case '1':
      holdNumberf=1;
      break;
      case '2':
      holdNumberf=2;
      break;
      case '3':
      holdNumberf=3;
      break;
      case '4':
      holdNumberf=4;
      break;
      case '5':
      holdNumberf=5;
      break;
      case '6':
      holdNumberf=6;
      break;
      case '7':
      holdNumberf=7;
      break;
      case '8':
      holdNumberf=8;
      break;
      case '9':
      holdNumberf=9;
      break;

      default:
       holdNumberf=0;
}
  if(toptenf>=10000000){
      makeintf=makeintf+holdNumberf*toptenLf;
      
  
      toptenLf=toptenLf*10; 
   }else{
     makeintf=makeintf+holdNumberf*toptenf; 
     

    toptenf=toptenf*10;  
   }
}
return makeintf;

}

我有一个问题，将“7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7d7d7c7d7c7d7c7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7c7c7c7c7c2e2e2e”这样的char数组转换成它的实际整数值，可以用“7C”表示为一个十六进制值。所以，在四处寻求帮助后，我创建了这个，并认为分享它会很酷。

这将字符字符串分离成正确的整数，可能对更多的人有帮助，而不仅仅是我;)

unsigned int* char2int(char *a, int len)
{
    int i,u;
    unsigned int *val = malloc(len*sizeof(unsigned long));

    for(i=0,u=0;i<len;i++){
        if(i%2==0){
            if(a[i] <= 57)
                val[u] = (a[i]-50)<<4;
            else
                val[u] = (a[i]-55)<<4;
        }
        else{
            if(a[i] <= 57)
                val[u] += (a[i]-50);
            else
                val[u] += (a[i]-55);
            u++;
        }
    }
    return val;
}

希望能有所帮助!

(这个答案解决了c++方面的问题，但C中也存在符号扩展问题。)

处理所有三种char类型(有符号、无符号和char)比最初看起来更精细。0到SCHAR_MAX(对于8位字符是127)范围内的值很容易:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;

但是，当somevalue超出该范围时，只有通过unsigned char才能在所有三种类型中获得“相同”char值的一致结果:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
// Might not be true: int(c) == int(sc) and int(c) == int(uc).
int nc = (unsigned char)c;
int nsc = (unsigned char)sc;
int nuc = (unsigned char)uc;
// Always true: nc == nsc and nc == nuc.

这在使用ctype.h中的函数时很重要，例如isupper或toupper，因为符号扩展:

char c = negative_char;  // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n);  // Undefined behavior.

注意到int的转换是隐式的;这有相同的UB:

char c = negative_char;
bool b = isupper(c);

要解决这个问题，使用unsigned char，这很容易通过safe_ctype包装ctype.h函数:

template<int (&F)(int)>
int safe_ctype(unsigned char c) { return F(c); }

//...
char c = CHAR_MIN;
bool b = safe_ctype<isupper>(c);  // No UB.

std::string s = "value that may contain negative chars; e.g. user input";
std::transform(s.begin(), s.end(), s.begin(), &safe_ctype<toupper>);
// Must wrap toupper to eliminate UB in this case, you can't cast
// to unsigned char because the function is called inside transform.

这是可行的，因为任何接受三种char类型中的任何一种的函数也可以接受另外两种char类型。它导致两个可以处理任何类型的函数:

int ord(char c) { return (unsigned char)c; }
char chr(int n) {
  assert(0 <= n);  // Or other error-/sanity-checking.
  assert(n <= UCHAR_MAX);
  return (unsigned char)n;
}

// Ord and chr are named to match similar functions in other languages
// and libraries.

Ord (c)总是给你一个非负值-即使传递一个负字符或负符号字符- CHR取Ord产生的任何值并返回完全相同的字符。

在实践中，我可能只使用unsigned char类型而不是使用这些类型，但它们确实简洁地包装了类型转换，提供了一个方便的地方来添加int-to-char类型的错误检查，并且在需要多次使用它们时更简短、更清楚。

我在C语言中有绝对的零技能，但对于一个简单的解析:

char* something = "123456";

int number = parseInt(something);

.．.这招对我很管用:

int parseInt(char* chars)
{
    int sum = 0;
    int len = strlen(chars);
    for (int x = 0; x < len; x++)
    {
        int n = chars[len - (x + 1)] - '0';
        sum = sum + powInt(n, x);
    }
    return sum;
}

int powInt(int x, int y)
{
    for (int i = 0; i < y; i++)
    {
        x *= 10;
    }
    return x;
}

使用static_cast < int >:

int num = static_cast<int>(letter); // if letter='a', num=97

编辑:你可能应该尽量避免使用(int)

Int num = (Int)字母;

为什么使用static_cast<int>(x)而不是(int)x?更多信息。

int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}

您可以使用此atoi方法将char转换为int。想了解更多信息，可以参考这个http://www.cplusplus.com/reference/cstdlib/atoi/， http://www.cplusplus.com/reference/string/stoi/。