You can use a library or you can write a helper function. The helper function would look something like this (pseudocode):

int output = 0;
for (int i = 0; i < string.length; i++) {
  output = output * 10;
  output = output + parse(string[i]) //parse first character into a single digit
}

For example, if you have 253, it will read 2. Then it will multiply it by 10 (20) and add 5 (25). Then it will multiply that by 10 (250) and add 3, which will be the expected output.

Note that you need to find a way to parse a single character of your string into a single digit integer - that should be very easy using something like a switch() statement.

EDIT: If you are looking for a library function, check out this question:

What is the difference between sscanf or atoi to convert a string to an integer?

How exactly would you like the conversion to work? Do you simply want an array containing the ASCII value of each character in the array? (so "abc" becomes [97, 98, 99, 0])?

Or do you want to parse the string somehow? ("1, 2, 3" becomes an array [1, 2, 3])

In the first case, in C++, I'd do something like this:

struct convert {
  int operator()(char c) {
    return static_cast<int>(c);
  }
};

std::string str = "hello world";
std::vector<int> result;
std::transform(str.begin(), str.end(), std::back_inserter(result), convert())

Of course you could use a raw array instead of the vector, but since the length of the string is probably going to be variable, and then arrays are just asking for trouble.

If this wasn't what you wanted, you might want to edit your question to be more specific.

The commenters found most of it, so to put it all together

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

// ALL CHECKS OMMITTED!

int main()
{
  int16_t frame[5] = { 10, 2, 3, 7, 5 };
  // hexadecimal string = 2 characters plus NUL
  // sizeof(char) == 1, if compiler is standard compliant
  char *str = malloc(3 * (sizeof(frame)/sizeof(frame[0]) +1));
  char *strp = str;
  size_t j;
  for (j = 0; j < sizeof(frame)/sizeof(frame[0]); j++) {
    // again: hexadecimal string = 2 characters plus NUL
    snprintf(strp, 3, "%02x", frame[j]);        //hexadecimal 
    strp += 2;
  }
  // we need a pointer to the start of the string to free it later
  strp = str;
  // let's see if we gott all of them
  printf("str = %s\n",str);
  // from hexa string to 16 bit integer array
  int16_t n_oframe[5];
  size_t i_m;
  // and again: hexadecimal string = 2 characters plus NUL
  // a simple char d[3]; would have been more than suffcient
  // for the task, but if stack is precious...
  char *d = (char *) malloc(3);
  for (i_m = 0; i_m < 5; i_m++) {
    // it's always the same, just do it once at the beginning
    //char *d = (char *) malloc(3);
    strncpy(d, str, 2);
    // atol() is for base 10 input only, use strtol() instead
    n_oframe[i_m] = (int16_t)strtol(d,NULL,16);
    str = str + 2;
    //free(d);
  }
  for (j = 0; j < 5; j++) {
     printf("%d ", n_oframe[j]);
  }
  putchar('\n');

  free(d);
  free(strp);
  exit(EXIT_SUCCESS);
}

I changed gint16 to int16_t because I do not know what that is supposed to be. You can most likely replace it with gint16 without problems.

You are declaring your array arr every time you loop.

change your loop like this:

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

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

    int arr[argc];
    int i=0;


    for(i = 0; i < argc-1; i++)
    {
       arr[i] = atoi(argv[i+1]);
       printf("arr[%d] = %d\n",i,arr[i]);
    }

    return 0;
}

Here is the output:

Sukhvir@Sukhvir-PC ~
$ gcc -Werror -Wall -g -o test test.c

Sukhvir@Sukhvir-PC ~
$ ./test 3 4 5
arr[0] = 3
arr[1] = 4
arr[2] = 5

Seeing as this is homework you could also do

output[i] = input[i] - '0';

but be careful that input[i] is actually a digit (i.e. it's between '0' and '9')!

int* myarray = new int[ userstr.size() ];

std::copy( usestr.begin(), userstr.end(), myarray ); 

The terminating zero was not appended to the array. If you need it you should allocate the array having one more element and place the terminating zero yourself.