C++ char2int函数代码示例

/* Setup lexer state. */
void lj_lex_setup(lua_State *L, LexState *ls)
{
  ls->L = L;
  ls->fs = NULL;
  ls->n = 0;
  ls->p = NULL;
  ls->vstack = NULL;
  ls->sizevstack = 0;
  ls->vtop = 0;
  ls->bcstack = NULL;
  ls->sizebcstack = 0;
  ls->lookahead = TK_eof;  /* No look-ahead token. */
  ls->linenumber = 1;
  ls->lastline = 1;
  lj_str_resizebuf(ls->L, &ls->sb, LJ_MIN_SBUF);
  next(ls);  /* Read-ahead first char. */
  if (ls->current == 0xef && ls->n >= 2 && char2int(ls->p[0]) == 0xbb &&
      char2int(ls->p[1]) == 0xbf) {  /* Skip UTF-8 BOM (if buffered). */
    ls->n -= 2;
    ls->p += 2;
    next(ls);
  }
  if (ls->current == '#') {  /* Skip POSIX #! header line. */
    do {
      next(ls);
      if (ls->current == END_OF_STREAM) return;
    } while (!currIsNewline(ls));
    inclinenumber(ls);
  }
  if (ls->current == LUA_SIGNATURE[0]) {
    setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XBCLOAD));
    lj_err_throw(L, LUA_ERRSYNTAX);
  }
}

bool encodeHexString(uint8_t *data, uint32_t dataLength, const char* key, bool swapEndian)
{
	if (swapEndian)
	{
		for (int i = dataLength * 2 - 2; i >= 0; i -= 2)
		{
			int c1 = char2int(key[i]);
			int c2 = char2int(key[i + 1]);
			if (c1 == -1 || c2 == -1)
				return false;
			*data++ = c1 * 16 + c2;
		}
	}
	else
	{
		for (int i = 0; i < dataLength * 2; i += 2)
		{
			int c1 = char2int(key[i]);
			int c2 = char2int(key[i + 1]);
			if (c1 == -1 || c2 == -1)
				return false;
			*data++ = c1 * 16 + c2;
		}
	}

	return true;
}

/*
  args:
     s           character string representing hex digits
     len         length of s (it does not need to be null-terminated) 
     intbuf      pre-allocated array of integers into which the result
                 will be placed, 3 bytes per int.  no checks
                 are made as to the length being sufficient, this is the
                 caller's responsibility, strlen(s)/6 + 1 is enough

  returns:
    length of int buf used

  this function packs an array of characters representing hex digits
  into an array of ints, 3 bytes per int
*/
int hexstring2int(char *s, int len, unsigned int *intbuf) {
  int s_ind = 0, int_ind = 0;
  int remainder;
  int i;

  remainder = len%6;
  int_ind = 0;
  intbuf[int_ind] = 0;
  while (remainder && s_ind < len) {
    intbuf[int_ind] = char2int(s[s_ind++]) | (intbuf[int_ind] << 4);
    remainder -=1;
    len-=1;
  }
  if (intbuf[int_ind]) int_ind++;
  
  while (len>0) {
    intbuf[int_ind] = 0;
    for (i=0; i<6; i++) {
      intbuf[int_ind] = char2int(s[s_ind++]) | (intbuf[int_ind] << 4);
    }    
    len -=6;
    int_ind++;
  }
  return(int_ind);
}

int str2int(char *str){

    //printf("%s\n", str);
    int tam = strlen(str);
    //printf("%d\n", tam);

    int sum = 0;

    int i;

    //printf("\n%d\n", tenPow(4));

    for(i = tam-1; i > 0; i--){
        //printf("%c %d %d\n", str[i], char2int(str[i]), tenPow(tam-1-i));//(tam-1-i)
        sum += (char2int(str[i]) * tenPow(tam-1-i));
    }


    if(str[i] == '-')
        sum *= -1;
    else
        sum += (char2int(str[i]) * tenPow(tam-1));

    //printf(">%d<\n", sum);

    return sum;
}

int sim_blosum(char* seq1, char* seq2)
{
   int len = (strlen(seq1) < strlen(seq2) ? (int)strlen(seq1) : (int)strlen(seq2));
   int sim = 0;
   for (int i=0; i<len; i++)
      sim = Sum_INT_MIN2(sim,BLOSUM[char2int(seq1[i])][char2int(seq2[i])]);
   return sim;
}

// This function assumes src to be a zero terminated sanitized string with
// an even number of [0-9a-f] characters, and target to be sufficiently large
void Utils::hex2bin(const uint8_t* src, uint8_t* target)
{  // https://stackoverflow.com/questions/17261798/
  while (*src && src[1])
  {
    *(target++) = char2int(*src) * 16 + char2int(src[1]);
    src += 2;
  }
}

static void parse_cryptokey(AVFormatContext *avfc, const char *str) {
    int len = strlen(str) / 2;
    uint8_t *key = av_mallocz(len);
    int i;
    avfc->keylen = len;
    avfc->key = key;
    for (i = 0; i < len; i++, str += 2)
        *key++ = (char2int(str[0]) << 4) | char2int(str[1]);
}

int main(void)
{
    char (*a)[1000],(*b)[1000],(*c)[1100];
    char sum;
    int T,i = 0,j = 0;
    scanf("%d",&T);
    c = (char (*)[1100])malloc(sizeof(char) * 1100 * T);
    a = (char (*)[1000])malloc(sizeof(char) * 1000 * T);
    b = (char (*)[1000])malloc(sizeof(char) * 1000 * T);

    for(i = 0 ;i < T;i++)
    {
        memset(a[i],0,sizeof(a[i]));
        memset(b[i],0,sizeof(b[i]));
        memset(c[i],0,sizeof(c[i]));

        scanf("%s",a[i]);
        scanf("%s",b[i]);

        int len_a,len_b;
        len_a = strlen(a[i]);
        len_b = strlen(b[i]);
        int carry = 0;
        j = 0;
        while(len_a > j || len_b > j)
        {
            if(j < len_a && j < len_b)
                c[i][j] = char2int(a[i][len_a -1 - j]) + char2int(b[i][len_b -1 - j]) + carry;
            else if(j < len_b && j >= len_a)
                c[i][j] = char2int(b[i][len_b -1 - j]) + carry;
            else if(j < len_a && j >= len_b)
                c[i][j] = char2int(a[i][len_a -1 - j]) + carry;
            else
                break;
            carry = c[i][j] / 10;
            c[i][j] = c[i][j] % 10;
            c[i][j] = int2char(c[i][j]);
            j++;
        }
         if(carry)
             c[i][j] = int2char(carry);
    }
    for(i = 0;i < T ;i++)
    {
         printf("Case %d:\n", i+1);
         printf("%s + %s = ", a[i],b[i]);

         for(j = strlen(c[i]) - 1;j >= 0;j--)
             printf("%c", c[i][j]);
         if(i != T -1)
             printf("\n");
         printf("\n");
    }
    free(a);
    free(b);
    free(c);
}

std::vector<byte> FromHexStringToByte(std::string input)
{
    std::vector<byte> data; //= new byte[input.Length / 2];
    std::string HexByte = "";

    for (int i = 0; i < input.length() / 2; i++) {
        HexByte = input.substr(i * 2, 2);
        unsigned char temp = char2int(HexByte[0]) * 16 + char2int(HexByte[1]);
        data.push_back(temp);
    }

    return data;
}

int* nucchar_to_aaint(char* nuc_seq)
{
   int nuc_length = (int)strlen(nuc_seq);
   int* int_nuc_seq = char2int(nuc_seq);

   return nucint_to_aaint(int_nuc_seq,nuc_length);
}

Block getWordBlock(std::string word, std::fstream& f, bool createIfReauired = false) {
  seekRW(f, 0);
  BlockOffset currentOffset = 0;
  Block b {readBlockFromFile(f)};

  for(auto c : word) {
    unsigned int i = char2int(c);

    if (b.offsets[i] == 0 ) {
      if (!createIfReauired) {
	b.data=0;
	return b;
      }
      BlockOffset off = f.tellp();
      Block newBlock {};
      seekRW(f, 0, f.end); 
      BlockOffset newCurrent = b.offsets[i] = writeBlockToFile(newBlock, f);
      seekRW(f, off);
      writeBlockToFile(b, f);
      seekRW(f, newCurrent);
      currentOffset = newCurrent;
      b = newBlock;
    } else {
      currentOffset = b.offsets[i];
      seekRW(f, currentOffset);
      b = readBlockFromFile(f);
    }
  }

  return b;
}

/* Setup lexer state. */
int lj_lex_setup(lua_State *L, LexState *ls)
{
  int header = 0;
  ls->L = L;
  ls->fs = NULL;
  ls->n = 0;
  ls->p = NULL;
  ls->vstack = NULL;
  ls->sizevstack = 0;
  ls->vtop = 0;
  ls->bcstack = NULL;
  ls->sizebcstack = 0;
  ls->lookahead = TK_eof;  /* No look-ahead token. */
  ls->linenumber = 1;
  ls->lastline = 1;
  lj_str_resizebuf(ls->L, &ls->sb, LJ_MIN_SBUF);
  next(ls);  /* Read-ahead first char. */
  if (ls->current == 0xef && ls->n >= 2 && char2int(ls->p[0]) == 0xbb &&
      char2int(ls->p[1]) == 0xbf) {  /* Skip UTF-8 BOM (if buffered). */
    ls->n -= 2;
    ls->p += 2;
    next(ls);
    header = 1;
  }
  if (ls->current == '#') {  /* Skip POSIX #! header line. */
    do {
      next(ls);
      if (ls->current == END_OF_STREAM) return 0;
    } while (!currIsNewline(ls));
    inclinenumber(ls);
    header = 1;
  }
  if (ls->current == LUA_SIGNATURE[0]) {  /* Bytecode dump. */
    if (header) {
      /*
      ** Loading bytecode with an extra header is disabled for security
      ** reasons. This may circumvent the usual check for bytecode vs.
      ** Lua code by looking at the first char. Since this is a potential
      ** security violation no attempt is made to echo the chunkname either.
      */
      setstrV(L, L->top++, lj_err_str(L, LJ_ERR_BCBAD));
      lj_err_throw(L, LUA_ERRSYNTAX);
    }
    return 1;
  }
  return 0;
}

int luaZ_fill (ZIO *z) {
  size_t size;
  const char *buff = z->reader(NULL, z->data, &size);
  if (buff == NULL || size == 0) return EOZ;
  z->n = size - 1;
  z->p = buff;
  return char2int(*(z->p++));
}

bool sensownyBIK(std::string B)
{
    bool kontrola = true;

    kontrola &= (B.size() == 10);


    if(kontrola)
    {
        for(int i=0; i < 11; i++)
            {
                if(0 <= char2int(B[i]) && char2int(B[i]) <= 9);
                else kontrola = false;
            }
    }

    return kontrola;
}

static int fillbuf(LexState *ls)
{
  size_t sz;
  const char *buf = ls->rfunc(ls->L, ls->rdata, &sz);
  if (buf == NULL || sz == 0) return END_OF_STREAM;
  ls->n = (MSize)sz - 1;
  ls->p = buf;
  return char2int(*(ls->p++));
}