Use strtok like the following... arrayOfString will have list of strings.

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

int main()
{
   char str[80] = "apples, pears, oranges,";
   char* arrayOfString[3];
   const char s[2] = ", ";
   char *token;
   int i=0;
   /* get the first token */
   token = strtok(str, s);

   /* walk through other tokens */
   while( token != NULL ) 
   {
      arrayOfString[i] = token;
      token = strtok(NULL, s);
      i++;
   }

   for(i=0;i<3;i++)
    printf("%s\n", arrayOfString[i]);

   return(0);
}

Your data field only holds one char now. It needs to have room for at least the typical value, like 02/19/18.

Use char[10] for example (if you know for sure that it can never be longer than 9 characters).

I think the compiler ought to have warned against your fscanf call.

The function you are looking for is strtok. That means String Tokenizer.

I think this will work for you:

  char str[] = get_order_type(optarg);
   const char s[2] = ",";
   char *token;

   /* get the first token */
   token = strtok(str, s);

   /* walk through other tokens */
   while( token != NULL ) 
   {
      printf( " %s\n", token );

      token = strtok(NULL, s);
   }

Anyway, here you have the documentation for the method.

Hope it helps!!

Arrays in C have a fixed size, whatever size you declare an array is the size it’s going to stay. You don’t “push” anything on it, you overwrite its contents, e.g: charArray[length] = ch; This won’t work with your current set up though, because your array is declared with a size of zero. If you want your array to hold, say 100 bytes, you would declare it like so: char charArray[100]; But again, that array isn’t going to change its size. If you want to be able to read a file with this format and copy it to an array regardless of size, you’ll need to manage the memory yourself using malloc() and realloc().

Hi, · This should work, please change your string as shown · var str = "Shoe,Tie,Blazer"; · var arr = str.split(","); · //alert(arr[0]); · Thank You · Please Hit Like, Helpful or Correct depending on the impact of response

Try this small User Defined Function:

Public Function PeopleKounter(s As String) As Long
    Dim DQ As String, c As Collection
    Set c = New Collection
    DQ = Chr(34)

    ary = Split(Replace(s, DQ, ""), ",")

    On Error Resume Next
        For Each a In ary
            c.Add a, CStr(a)
        Next a
    On Error GoTo 0

    PeopleKounter = c.Count
End Function

string s = "1,5,7";
int[] nums = Array.ConvertAll(s.Split(','), int.Parse);

or, a LINQ-y version:

int[] nums = s.Split(',').Select(int.Parse).ToArray();

But the first one should be a teeny bit faster.

const array = str.split(',');

MDN reference, mostly helpful for the possibly unexpected behavior of the limit parameter. (Hint: "a,b,c".split(",", 2) comes out to ["a", "b"], not ["a", "b,c"].)

You have several issues to work through to convert your function from simply printing the separated strings to stdout to saving the separated strings in ArrayOfString. Before getting to the changes, let's avoid using magic numbers in your code.

char ArrayOfString[10][5];

In ArrayOfString above, 10 and 5 are magic numbers. They are hardcoded values that will govern everything from the declaration size to required validation checks to protect your array bounds. Instead of hardcoding values, if you need a constant, define one (or more), e.g.

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

#define ROW 10
#define COL  5

char ArrayOfString[ROW][COL];

Now on to separating your string into tokens. The C-library provides a function specifically tailored to separating delimited strings into tokens. Conveniently named strtok. The only caveat to know about strtok is that it modifies the string, so if you need to preserve the original, make a copy first.

To use strtok (string, delims) to separate string into tokens at delims, your first call to strtok takes string as the 1st parameter. All subsequent calls use NULL in its place. You can either make an initial call to strtok and then use a while loop to complete the process, or a for loop is tailor made for handling the initial call, as well as all subsequent calls with NULL.

For example your function utilizing strtok to separate string into tokens and providing a size_t return of the number of tokens copied to ArrayOfString could be similar to:

char ArrayOfString[ROW][COL];

size_t vSeparateSringByComma (char* string)
{
    const char *delims = ",\n";
    char *s = string;
    size_t n = 0, len;

    for (s = strtok (s, delims); s && n < ROW; s = strtok (NULL, delims))
        if ((len = strlen (s)) < COL)
            strcpy (ArrayOfString[n++], s);
        else
            fprintf (stderr, "error: '%s' exceeds COL - 1 chars.\n", s);

    return n;
}

(note: how your array bounds are protected both by the check with n < ROW and each row array bound is protected with (len = strlen (s)) < COL before the copy to ArrayOfString[n++] is made)

(also note: how by not using magic numbers, if you change the ROW or COL size in the future, only the constants need changing and the change is automatically incorporated throughout your code by virtue of using constants)

Your example program would then be:

int main(void) {

    char string[] = "$,0,3,307,183,18,5,119,1,#";
    size_t n = vSeparateSringByComma (string);

    for (size_t i = 0; i < n; i++)
        printf ("ArrayOfString[%zu] : '%s'\n", i, ArrayOfString[i]);
}

Example Use/Output

$ ./bin/arrayofstrings
ArrayOfString[0] : '$'
ArrayOfString[1] : '0'
ArrayOfString[2] : '3'
ArrayOfString[3] : '307'
ArrayOfString[4] : '183'
ArrayOfString[5] : '18'
ArrayOfString[6] : '5'
ArrayOfString[7] : '119'
ArrayOfString[8] : '1'
ArrayOfString[9] : '#'

Using strcspn and strspn Instead of strtok

As discussed in the comments, using strcspn to report the number of sequential characters not containing a delimiter allowing you to determined the length of each field. You then need to skip over the delimiters (which in many cases can be made up of more than one delimiter (e.g. $, 0, 3, ...).

While strtok considers multiple sequential delimiters a single delimiter, you would need a similar way to skip over the intervening delimiters to position your self to read the next field. strspn will work nicely using the same delims, but this time reporting the number of characters made up of only characters within delims (allowing you to add that to your len and then len to s to position yourself for the next read)

A short variation using strcspn and strspn could be:

size_t vSeperateSringByComma (char* string)
{
    const char *delims = ",\n";
    char *s = string;
    size_t n = 0, len;

    while ((len = strcspn (s, delims))) {   /* number of non-delim chars */
        if (len < COL) {                    /* validate it will fit */
            memcpy (ArrayOfString[n], s, len);  /* copy len chars */
            ArrayOfString[n++][len] = 0;    /* nul terminate at len */
        }
        else
            fprintf (stderr, "error: '%s' exceeds COL - 1 chars.\n", s);

        len += strspn (s + len, delims);    /* scan past delimiter(s) */
        s += len;               /* update s to beginning of next field */
    }

    return n;
}

(the output is the same)

Look things over and let me know if you have further questions.

One would 1st call the string's · split · method: · var list = ' item 1, item 2 , ,item 3 '; · var array = list · .split(','); · gs.debug('\n[' + array.join(']\n[') + ']'); · This prints: · *** Script: [DEBUG] · [ item 1] · [ item 2 ] · [ ] · [item 3 ] · Pretty all over the place. · For better result - where the leading and trailing spaces are removed - one would use · trim · before splitting: · var list = ' item 1, item 2 , ,item 3 '; · var array = list · .trim() · .split(','); · gs.debug('\n[' + array.join(']\n[') + ']'); · *** Script: [DEBUG] · [item 1] · [ item 2 ] · [ ] · [item 3] · Really only slightly better - only the 1st and the last items look good - and half of both only by chance (the one who entered the list did not add extra spaces after the last item and before the 1st one). · To take care of all extra spaces for all items that could exist due to sloppy fellow programmers composing the list or faulty data entry, one would switch the splitter to · RegExp · : · var list = ' item 1, item 2 , ,item 3 '; · var array = list · .trim() · .split(/\s*,\s*/g); · gs.debug('\n[' + array.join(']\n[') + ']'); · *** Script: [DEBUG] · [item 1] · [item 2] · [] · [item 3] · A lot better, almost there, just one problem remains: the 3rd item which is empty. · To take care of that problem one might · filter · the resulting array: · var list = ' item 1, item 2 , ,item 3 '; · var array = list · .trim() · .split(/\s*,\s*/g) · .filter(retainNotEmpty); · function retainNotEmpty (item) { · return '' != item; · } · gs.debug('\n[' + array.join(']\n[') + ']');​ · *** Script: [DEBUG] · [item 1] · [item 2] · [item 3] · Just about what one desires. · Filtering will also fix the issue of empty string ending up (not in a 0 length array, but) in an array with one item when split.

• sizeof(char) by definition is 1. tmp += l + 1; would be as good.

• I don't see a need to special case l == 0.

• You don't have to initialize l in a loop header: it is immediately reassigned.

• gcc complains about precision specifier in printf("\"%.*s\"\n", l, tmp) being size_t; unfortunately, cast is unavoidable.

• I don't see a need for 2 separate loops. A single

  char * tmp = (char *)str;
  do {
      int l = strcspn (tmp, tok);
      printf("\"%.*s\"\n", l, tmp);
      tmp += l + 1;
  } while (tmp[-1]);
  return 0;
  

  works equally well.