libopcodes c disassembly file load open and process

Question

I m trying to load a file and disassemble the content in hexadecimal format. Here is the code that I came so far ;

struct stat st;

using namespace std;

typedef struct {
  char *insn_buffer;
  bool reenter;
} stream_state;

int dis_fprintf(void *stream, const char *fmt, ...) {
  stream_state *ss = (stream_state *)stream;

  va_list arg;
  va_start(arg, fmt);
  if (!ss->reenter) {
    vasprintf(&ss->insn_buffer, fmt, arg);
    ss->reenter = true;
  } else {
    char *tmp;
    vasprintf(&tmp, fmt, arg);

    char *tmp2;
    asprintf(&tmp2, "%s%s", ss->insn_buffer, tmp);
    free(ss->insn_buffer);
    free(tmp);
    ss->insn_buffer = tmp2;
  }
  va_end(arg);

  return 0;
}

int fprintf_styled (FILE *f, enum disassembler_style style ATTRIBUTE_UNUSED,
        const char *fmt, ...)
{
  int res;
  va_list ap;

  va_start (ap, fmt);
  res = vfprintf (f, fmt, ap);
  va_end (ap);

  return res;
}


char *disassemble_raw(uint8_t *input_buffer, size_t input_buffer_size) {
  char *disassembled = NULL;
  stream_state ss = {};

  disassemble_info disasm_info = {};
  init_disassemble_info(&disasm_info, stdout, (fprintf_ftype) fprintf, (fprintf_styled_ftype) fprintf_styled);
  disasm_info.arch = bfd_arch_i386;
  disasm_info.mach = bfd_mach_x86_64;
  disasm_info.read_memory_func = buffer_read_memory;
  disasm_info.buffer = input_buffer;
  disasm_info.buffer_vma = 0;
  disasm_info.buffer_length = input_buffer_size;
  disassemble_init_for_target(&disasm_info);

  disassembler_ftype disasm;
  disasm = disassembler(bfd_arch_i386, false, bfd_mach_x86_64, NULL);

  size_t pc = 0;
  while (pc < input_buffer_size) {
    size_t insn_size = disasm(pc, &disasm_info);
    pc += insn_size;

    if (disassembled == NULL) {
      asprintf(&disassembled, "%s", ss.insn_buffer);
      printf("\n");
    } else {
      char *tmp;
      asprintf(&tmp, "%s\n%s", disassembled, ss.insn_buffer);
      free(disassembled);
      disassembled = tmp;
      printf("\n");
    }
    free(ss.insn_buffer);
    ss.reenter = false;
  }

  return disassembled;
}


int main(int argc, char const *argv[]) {

string Filename = "file";
FILE* pFile;
pFile = fopen(Filename.c_str(), "rb");
fseek(pFile, 0L, SEEK_END);
size_t size = ftell(pFile);
fseek(pFile, 0L, SEEK_SET);
uint8_t* ByteArray;
ByteArray = new uint8_t[size];
if (pFile != NULL)
{
    int counter = 0;
    do {
        ByteArray[counter] = fgetc(pFile);
        cout << fgetc(pFile);
        counter++;
    } while (counter <= size);
    fclose(pFile);
}

  size_t ByteArray_size = sizeof(ByteArray);

  char *disassembled = disassemble_raw(ByteArray, ByteArray_size);

  free(disassembled);
  cout << disassembled << endl;
  return 0;
}

but the result comes wrong not identical to objdump -d file output. Any suggestions how I can use libopcodes and load a file and disassemble then print to cout ? I want to be able to load a file in C or C ++ then get the output as strings or char array to print to console ?