Here is my take on it - the phex() function converts any data in memory into a newly allocated string containing the hex representation.

The main() function shows an example usage. The output is "31323334353637383930" for the example data.

#include <stdlib.h> /* malloc() */
#include <stdio.h>  /* sprintf() */
#include <string.h> /* strlen(), in the example main() */

/*
 * Return a hex string representing the data pointed to by `p`,
 * converting `n` bytes.
 *
 * The string should be deallocated using `free()` by the caller.
 */
char *phex(const void *p, size_t n)
{
    const unsigned char *cp = p;              /* Access as bytes. */
    char *s = malloc(2*n + 1);       /* 2*n hex digits, plus NUL. */
    size_t k;

    /*
     * Just in case - if allocation failed.
     */
    if (s == NULL)
        return s;

    for (k = 0; k < n; ++k) {
        /*
         * Convert one byte of data into two hex-digit characters.
         */
        sprintf(s + 2*k, "%02X", cp[k]);
    }

    /*
     * Terminate the string with a NUL character.
     */
    s[2*n] = '\0';

    return s;
}

/*
 * Sample use of `phex()`.
 */
int main(void)
{
    const char *data = "1234567890";               /* Sample data */
    char *h = phex(data, strlen(data));  /* Convert to hex string */

    if (h != NULL)
        puts(h);                                  /* Print result */

    free(h);                             /* Deallocate hex string */
    return 0;
}

Use %x flag to print hexadecimal integer

example.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) 
{
  char *string = "hello", *cursor;
  cursor = string;
  printf("string: %s\nhex: ", string);
  while(*cursor)
  {
    printf("%02x", *cursor);
    ++cursor;
  }
  printf("\n");
  return 0;
}

output

$ ./example 
string: hello
hex: 68656c6c6f

reference

• printf reference
• ascii table

Here is something:

char const hex_chars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
string result = "";

for( int i = 0; i < data_length; ++i )
{
    char const byte = data[i];

    result += hex_chars[ ( byte & 0xF0 ) >> 4 ];
    result += hex_chars[ ( byte & 0x0F ) >> 0 ];
}

I would do something like this;

// Convert from ascii hex representation to binary
// Examples;
//   "00" -> 0
//   "2a" -> 42
//   "ff" -> 255
// Case insensitive, 2 characters of input required, no error checking
int hex2bin( const char *s )
{
    int ret=0;
    int i;
    for( i=0; i<2; i++ )
    {
        char c = *s++;
        int n=0;
        if( '0'<=c && c<='9' )
            n = c-'0';
        else if( 'a'<=c && c<='f' )
            n = 10 + c-'a';
        else if( 'A'<=c && c<='F' )
            n = 10 + c-'A';
        ret = n + ret*16;
    }
    return ret;
}

int main()
{
    const char *in = "0011223344";
    char out[5];
    int i;

    // Hex to binary conversion loop. For example;
    // If in="0011223344" set out[] to {0x00,0x11,0x22,0x33,0x44}
    for( i=0; i<5; i++ )
    {
        out[i] = hex2bin( in );
        in += 2;
    }
    return 0;
}

This should work:

    char hex[255] = {0};       // Varible to hold the hex value
    int dec = 1234;            // Decimal number to be converted
    sprintf(hex,"%X", dec);
    printf("%s", hex);         // Print hex value

Just use the same function for std::string but with char *,

#include <iostream>                                                    
#include <cstdlib>                                                     
#include <cstring>                                                     
#include <string>                                                      

using namespace std;                                                   

char *string_to_hex(char *input) {                                     
    static const char *const lut = "0123456789ABCDEF";                 
    size_t len = strlen(input);                                        
    int k = 0;                                                         
    if (len & 1)                                                       
        return NULL;                                                   

    char *output = new char[(len / 2) + 1];                            

    for (size_t i = 0, j = 0; i < len; i++, j += 2) {                  
        const unsigned char c = input[i];                              
        output[j]     = lut[c >> 4];                                       
        output[j + 1] = lut[c & 15];                                   
    }                                                                  

    return output;                                                     
}                                                                      

std::string string_to_hex(const std::string &input) {                  
    static const char *const lut = "0123456789ABCDEF";                 
    size_t len = input.length();                                       

    std::string output;                                                
    output.reserve(2 * len);                                           
    for (size_t i = 0; i < len; ++i) {                                 
        const unsigned char c = input[i];                              
        output.push_back(lut[c >> 4]);                                 
        output.push_back(lut[c & 15]);                                 
    }                                                                  
    return output;                                                     
}                                                                      

int main() {                                                           
    string test = "Test";                                              
    std::string res(string_to_hex(test.c_str()));                      
    cout << res << endl;                                               
    res = string_to_hex(test);                                         
    cout << res << endl;                                               
}                                                                      

unsigned char flags = 0; flags = ((O << 3) | (C << 2) | (Z << 1) | N);

now flag contains the Hex value you need.

Another simple way is to print "&#" + CharCode like this:

for(var i=9984; i<=10175; i++){
    document.write(i + "&nbsp;&nbsp;&nbsp;" + i.toString(16) + "&nbsp;&nbsp;&nbsp;&#" + i + "<br>");
}

OR

for(var i=0x2700; i<=0x27BF; i++){
    document.write(i + "&nbsp;&nbsp;&nbsp;" + i.toString(16) + "&nbsp;&nbsp;&nbsp;&#" + i + "<br>");
}

JSFIDDLE