arrays of strings in C++

Your code currently only copies pointers to tokens that you get through strtok. These tokens are stored in a static copy of your input string, which you stored in line. This means that each time you make a new call to strtok at the start of a new line, this static copy will be overwritten with the new line, and thus your previous pointers will all be invalidated: they still point into valid memory, but the contents therein are different!

Therefore, it may well be that your code worked as long as you only looked at a one-line input file. but the moment you start reading the second line and apply strtok to it, your program breaks.

As others have pointed out, it would be wiser to use std::string and std::vector like this:

std::vector<std::vector<std::string> > arr; // dynamic 2D array of dynamic strings

For just a quick fix, it would suffice to replace the char* from your declaration:

std::string arr[50][50]; // fixed size 2D array of dynamic strings

But note, that if you ever have more than 50 lines or more than 50 strings per line, your program will break!

Changing the type like this will result in changing the meaning of

arr[i][j] = toks;

from merely copying the pointer to actually copying the string that toks points to. This should be sufficient to fix your problem for now.

Basically you are handling badly the C-like strings, inserting temporary character pointers into your array.
Since you are using C++ why don't you exploit its standard library?
Try, for instance:

#include<iostream>
#include <vector>
#include<fstream>
#include<string>
using namespace std;

int main()
{
  ifstream myfile("sample.csv");

  vector < vector< string > > ar;
  while (true)
  {
    string s;
    size_t lastpos, curpos;

    getline(myfile, s);
    if ( !myfile) break;
    ar.push_back( vector<string>());
    for (lastpos=curpos=0; curpos!=string::npos; lastpos=curpos+1)
    {
      curpos = s.find(',', lastpos);
      if (curpos != string::npos)
        ar.back().push_back(s.substr(lastpos, curpos-lastpos));
      else
        ar.back().push_back(s.substr(lastpos));
    }
  }

  myfile.close();

  for (size_t i=0; i < ar.size(); i++)
  {
    for (size_t j=0; j < ar[i].size(); j++)
    {
        cout << ar[i][j] << "\t";
    }
    cout << endl;
  }
  return 0;
}

In your code you are saving pointers to each item, but then overwriting the data with the next line. By the time you come to your output routine the original data pointed at by the elements of your array has been overwritten. The only remaining pointers that are valid are the ones for the last line read in. You should use std::string and std::vector to ensure that each string you break out is copied to a permanent location before you read the next line.

This is just an explanation on how to use vector, since you asked about that in response to Carlos solution. Here is a bit of code with comments that explain its differences to a standard array:

int arr[50];        // standard array with 50 elements of type int
int* parr = arr;    // ok: arr is an array, but it is also the address
                    // of the first element
int n_arr_elements = sizeof(arr)/sizeof(int); // this evaluates to 50,
                    // the number of elements in arr
arr[5] = 17;        // assign the value 17 to the sixth element of arr
arr[500] = 23;      // error! this will likely cause an error at runtime,
                    // since you are writing past the end of your array!

vector<int> vec;    // vector holding elements of type int
size_t n_vec_elements = vec.size(); // this evaluates to the _current_
                    // number of elements in vec; right now, it is 0
int* pvec = vec;    // compiler error: can not convert std::vector<int> to int*
pvec = &(vec[0]);   // ok: now pvec points to the first element
vec[5] = 17;        // resize vector to hold at least six elements, then
                    // assign 17 to sixth element
n_vec_elements = vec.size(); // now the size will be 6
vec[500] = 23;      // ok: vec will be resized to hold 501 elements, then
                    // the 500th gets assigned
n_vec_elements = vec.size(); // now the size will be 501

As you see, vector behaves quite similar to a standard array, with the following differences:
- a variable of type vector is not convertible to a pointer
- a vector resizes itself dynamically, as needed; you will never accidentally read or write past the end of the buffer
- you can easily query the current size of a vector, but you cannot rely on it to stay the same

Dear Richard,

I have tried using it on a different context and it works fine.Its not been overwritten by the next line as per my knowledge. If in case i am wrong, then please suggest me with the desired changes to my code.

Thanks

Deepak