you can use sprintf (note if you sprintf past the end of the 'str' array, you will have a buffer overflow):

//malloc 2 chars for each byte of data (for 2 hex digits)
char *str = malloc(sizeof(char) * 3 * (sizeof(data) + 1));

//this var will point to the current location in the output string
char *strp = str;

if (NULL == str)
{
    return false; //memory error
}

for (size_t i= 0; i < sizeof(data); i++) {
    snprintf(strp, 2, "%02X ", data[i]);
    strp++;
}

// now the memory in *str holds your hex string!

For printing out hex values, you can use std::hex format; for setting width and fill character, use std::setw and std::setfill, which are part of <iomanip>. As you do not show the data type of c, I suppose/suggest to use an unsigned integral type, e.g. unsigned char. I slightly adapted the code to make it self contained):

#define SHA256_DIGEST_LENGTH 256

#include <iostream>
#include <sstream>
#include <iomanip>

int main() {

    unsigned char c[SHA256_DIGEST_LENGTH];
    for (unsigned int i=0; i<SHA256_DIGEST_LENGTH; i++)
        c[i]=i;

    std::stringstream ss;
    for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (unsigned int)c[i];
    }

    std::cout << ss.str();
}

Output:

000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff

Well, apparently std::string has a constructor that could be used in this case:

std::string str(reinterpret_cast<char*>(u_array), 4);

In C, a string is an array of char, terminated with a character whose value is 0.

Whether or not char is a signed or unsigned type is not specified by the language, you have to be explicit and use unsigned char or signed char if you really care.

It's not clear what you mean by "representing" an unsigned character array as string. It's easy enough to cast away the sign, if you want to do something like:

const unsigned char abc[] = { 65, 66,67, 0 }; // ASCII values for 'A', 'B', 'C'.

printf("The English alphabet starts out with '%s'\n", (const char *) abc);

This will work, to printf() there isn't much difference, it will see a pointer to an array of characters and interpret them as a string.

Of course, if you're on a system that doesn't use ASCII, there might creep in cases where doing this won't work. Again, your question isn't very clear.

For all practical purposes, the strcpy answers are correct, with the note that 8 isn't big enough for your string.

If you want to be really pedantic, you might need something like this:

#include <algorithm>

int main() {
    const char greeting[] = "Hello world";
    unsigned char m_Test[sizeof(greeting)];
    std::copy(greeting, greeting + sizeof(greeting), m_Test);
}

The reason is that std::copy will convert the characters in the original string to unsigned char. strcpy will result in the characters in the original string being reinterpreted as unsigned char. You don't say which one you want.

The standard permits there to be a difference between the two, although it's very rare: you'd need char to be signed, in an implementation with a 1s' complement or sign-magnitude representation. You can pretty much ignore the possibility, but IMO it's worth knowing about, because it explains the funny warnings that good compilers give you when you mix up pointers to char and unsigned char.