String converter(uint8_t *str){
    return String((char *)str);
}

Simply convert it :

fmt.Println(strconv.Itoa(int(str[1])))

Update for Swift 3/Xcode 8:

String from bytes: [UInt8]:

if let string = String(bytes: bytes, encoding: .utf8) {
    print(string)
} else {
    print("not a valid UTF-8 sequence")
}

String from data: Data:

let data: Data = ...
if let string = String(data: data, encoding: .utf8) {
    print(string)
} else {
    print("not a valid UTF-8 sequence")
}

Update for Swift 2/Xcode 7:

String from bytes: [UInt8]:

if let string = String(bytes: bytes, encoding: NSUTF8StringEncoding) {
    print(string)
} else {
    print("not a valid UTF-8 sequence")
}

String from data: NSData:

let data: NSData = ...
if let str = String(data: data, encoding: NSUTF8StringEncoding) {
    print(str)
} else {
    print("not a valid UTF-8 sequence")
}

Previous answer:

String does not have a stringWithBytes() method. NSString has a

 NSString(bytes: , length: , encoding: )

method which you could use, but you can create the string directly from NSData, without the need for an UInt8 array:

if let str = NSString(data: data, encoding: NSUTF8StringEncoding) as? String {
    println(str)
} else {
    println("not a valid UTF-8 sequence")
}

You could just initialize the std::string with the sequence obtained from the std::vector<uint8_t>:

std::string str(v->begin(), v->end());

There is no need to play any tricks checking whether the std::vector<uint8_t> is empty: if it is, the range will be empty. However, you might want to check if the pointer is v is null. The above requires that it points to a valid object.

You are actually converting an array of uint8_t to a string. The canonical method is to use stringstream:

std::stringstream ss;
for (size_t i = 0; i < 6; ++i) {
    ss << MACAddress[i];
    if (i != 5) ss << ":";
}
std::string MACstring = ss.str();

You could avoid this by using to_string and concatenation:

std::string MACstring;
for (size_t i = 0; i < 6; ++i) {
    MACstring += std::to_string(MACAddress[i]);
    if (i != 5) MACstring += ":";
}

1.) it's a little bit faster to eliminate the int array.

2.) adding '0' changes the integer values 0 and 1 to their ascii values '0' and '1'.

3.) it's undefined behaviour to return the address of a local variable. You have to malloc memory in the heap.

4.) yes, just cut it out and do the whole operation all in one

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

typedef unsigned char uint8_t;

char *convert(uint8_t *a)
{
  char* buffer2;
  int i;

  buffer2 = malloc(9);
  if (!buffer2)
    return NULL;

  buffer2[8] = 0;
  for (i = 0; i <= 7; i++)
    buffer2[7 - i] = (((*a) >> i) & (0x01)) + '0';

  puts(buffer2);

  return buffer2;
}


int main()
{
  uint8_t example = 0x14;
  char *final_string;

  final_string = convert(&example);
  if (final_string)
  {
    puts(final_string);

    free(final_string);
  }
  return 0;
}

Try this:

std::ostringstream convert;
for (int a = 0; a < key_size_; a++) {
    convert << (int)key[a];
}

std::string key_string = convert.str();

std::cout << key_string << std::endl;

The ostringstream class is like a string builder. You can append values to it, and when you're done you can call it's .str() method to get a std::string that contains everything you put into it.

You need to cast the uint8_t values to int before you add them to the ostringstream because if you don't it will treat them as chars. On the other hand, if they do represent chars, you need to remove the (int) cast to see the actual characters.

EDIT: If your array contains 0x1F 0x1F 0x1F and you want your string to be 1F1F1F, you can use std::uppercase and std::hex manipulators, like this:

std::ostringstream convert;
for (int a = 0; a < key_size_; a++) {
    convert << std::uppercase << std::hex << (int)key[a];
}

If you want to go back to decimal and lowercase, you need to use std::nouppercase and std::dec.