The problem here is with

 char Tmp[]="";

here, Tmp is not an dynamic array, it's an array with exactly one element (initialized via the initializer). When you use this as destination for strcpy(), you're overrunning the buffer. Basically, your code tries to access out of bound memory, which invokes undefined behavior.

Related, quoting C11, chapter §7.24.2.3, strcpy(), emphasis mine

The strcpy function copies the string pointed to by s2 (including the terminating null character) into the array pointed to by s1. [...]

and then, for "String function conventions", §7.24.1,

[....] If an array is accessed beyond the end of an object, the behavior is undefined.

Solution: You need to ensure that Tmp has enough memory to hold the content to be copied into it, including the null terminator.

That said, for a hosted environment, int main() should at least be int main(void) to be conforming to the standard.

Praetorian hit it on the head. "The important rule you're missing is use std::string". Old C functions like strcpy_s are notoriously incredibly unreliable and that's the whole point of not doing it anymore. So don't do it. Use std::string.

Here's how to make your life easier:

/* Returns a word (delimited with whitespace) into a dynamically
 * allocated string, which is returned. Caller is responsible
 * for freeing the returned string when it is no longer needed.
 * On EOF or a read error, returns NULL.
 */
char* read_a_word(FILE* ifp) {
  char* word;
    /* Note the m. It's explained below. */
  if (fscanf(ifp, "%ms", &word) != 1)
    return NULL;
  return word;
}

The m qualifier in the scanf format means:

• An optional 'm' character. This is used with string conversions (%s, %c, %[), and relieves the caller of the need to allocate a corresponding buffer to hold the input: instead, scanf() allocates a buffer of sufficient size, and assigns the address of this buffer to the corresponding pointer argument, which should be a pointer to a char * variable (this variable does not need to be initialized before the call). The caller should subsequently free(3) this buffer when it is no longer required.

It's a Posix extension to the standard C library and is therefore required by any implementation which hopes to be Posix compatible, such as Linux, FreeBSD, or MacOS (but, unfortunately, not Windows). So as long as you're using one of those platforms, it's good.

That's not a character array; that's an array of character pointers. Remove the * to make it a character array:

char c[20];

Then you can use strcpy:

strcpy(c, "undefined");

If you really did want an array of character arrays, you'll have to do what you said you tried:

// array that holds 20 arrays that can hold up to 70 chars each
char c[20][70];

// copy "undefined" into the third element
strcpy(c[2], "undefined");

The problem could have been you're missing the closing ", I don't know if that was a paste error though. Or, the problem could have been that you're using k without defining it, we can't know without seeing the error message you get.

If you want to set them all to that string, then just loop over them:

char c[20][70];

int i;
for (i = 0; i < 20; ++i)
    strcpy(c[i], "undefined");

There are a few things I find troublesome. First, you've seen people say you should use std::string instead of char arrays, and that's true. But new programmers should understand the entire language, and so understanding how to use char arrays has value.

So let's ignore C++ strings and look at your code:

char ** test = createCharArray(); // array of pointers to char arrays
char *asd = new char[MAXSIZE];
cin >> asd;

for (int i = 0; i < PARAM_COUNT; ++i) {
    strcpy_s(test[i], asd);
}

for (int i = 0; i < PARAM_COUNT; ++i) {
    cout << i << " " << test[i] << endl;
}

deleteCharArray(test);
return 0;

Let's start with this. We don't know what createCharArray() does. Is it doing everything it should? Not only should it create an array of char pointers, but the way you're using it, it also needs to create the buffers they each point to. So it might look something like this:

char ** createCharArray() {
   char ** array = new char *[PARAM_COUNT];
   for (int index = 0; index < PARAM_COUNT; ++index) {
        array[index] = new char[MAXSIZE];
   }
   return array;
}

If yours looks remarkably different, you may have issues.

After that, let's look at this:

for (int i = 0; i < PARAM_COUNT; ++i) {
    strcpy_s(test[i], asd);
}

As others have said, this version of strcpy_s takes three arguments: strcpy_s(test[i], asd, MAXSIZE);

Note that you're copying the same string into place multiple times. I wonder if your code should really do this:

for (int i = 0; i < PARAM_COUNT; ++i) {
    cin >> asd;
    strcpy_s(test[i], asd, MAXSIZE);
}

And finally, the delete method needs to delete the individual pointers and then the array of pointers.

You haven't actually allocated memory for the pointer in data[current] leading to undefined behavior (and one of the possible outcomes of UB is that sometimes it seems to work fine).

Either allocate memory and assign it to the pointer, or use std::string instead (which is my recommendation).

In modern C++ there's really little reason to use pointers at all these days, least of all for strings. Using pointers just creates problems like the one you have, and more. And using std::string also means you won't have the risk of a buffer overflow if the user inputs a string longer than 19 characters.

There are a host of generally innocuous warnings that valgrind will throw from stdlib functions since they "cheat" a little. But this is not the case here:

char* c = new char; // this is bad

only allocates a char - not a buffer of chars, try:

char* c = new char[s->size()+1];

and then change the delete to:

delete [] c;

• Well clearly the error is using strcpy wrongly.

  The correct way would be

  strcpy(firstNames[set], firstName);
  

• Also in the loop it should be

      for (cset = 0; cset < MAX_COURSES; cset++)
      {
          strcpy(courses[cset], dynCourses);
          strcpy(grades[cset], dynGrades);
      }
  

  Note that the idiomatic C loop is for (int i = 0; i < MAX; i++), using < and not <=.

The signature of the strcpy function is

 char *strcpy(char * restrict s1, const char * restrict s2);

Earlier you passed in place of s1 a char instead of char*. You must have got some warning (if enabled). If not then turn all compiler flags -Wall -Werror.

             if (firstNames[set][cset] == '\0')

But if you are initially checking an uninitilized value with \0. This will higly unlikely will turn out to be false. There is no gurantee that the char array which doesn't contain strings will be initialized with 0 automatically. So make sure you have initialized the char arrays in the callee function like this

char arr[20][50]={0};

• The loop is from 0 to MAX_STUDENTS. You are invoking an undefined behavior looping on array index out of bound if MAX_STUDENTS is greater than or equal to 50. Same goes for MAX_COURSES. More clearly the looping would be for (set = 0; set < (50); set++).

• Again there will be a lot better way to deal with it if you put the initialization and copy part seperate. Otherwise this will be uneasy to maintain.

• Seeing your use courses it is obvious that you want to declare it like this

  char courses[5][20];
  

same goes for the grades array. Here you were trying to copy a string into into a 2d array. Compiler would complain about type incompatibility.

• Also in the function you didn't return anything meaningful. The correct way would be to return the index value on which new name or information is added.

• Here you are copying content of dynGrades and dynCourses to the array. So they will all contain the same values. Is this what you want? Because then what's the use of keeping 5 seperate char arrays - one could serve the purpose pretty well.

If you ever find yourself attempting to use sizeof() for anything that is sized dynamically, you're doing it wrong. Keep that in mind. sizeof() is used repeatedly in this code incorrectly. Dynamic size counts must be managed by you; the allocation size requirements in bytes can be managed using those counts in conjunction with a sizeof() of the fundamental type for the item being stored.

Given that:

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

int main(int argc, char *argv[])
{
    int i = 0;
    int arrayIndexes = 2;
    char ** myArray = malloc(arrayIndexes * sizeof(*myArray));

    //Allocate memory for each [x]
    for (i = 0; i < arrayIndexes; i++)
    {
        myArray[i] = malloc(254 * sizeof(char));
        sprintf(myArray[i], "string %d", i+1);
    }

    //Print out array values
    printf("Before: \n");
    for (i = 0; i < arrayIndexes; i++)
        printf("Array[%d]: %s\n", i, myArray[i]);

    // TODO: Fix this to check the result before orphaning the old
    //  value of myArray if an allocation failure ensues.
    myArray = realloc(myArray, (arrayIndexes+1) * sizeof(*myArray));
    ++arrayIndexes;

    //Allocate memory for the new string item in the array
    myArray[arrayIndexes-1] = malloc(254 * sizeof(char*));

    //Populate a new value in the array
    strcpy(myArray[arrayIndexes-1], "string 3"); //

    //Print out array values
    printf("After: \n");
    for (i = 0; i < arrayIndexes; i++)
        printf("Array[%d]: %s\n",i, myArray[i]);

    // TODO: write proper cleanup code just for good habits.
    return 0;
}

Output

Before: 
Array[0]: string 1
Array[1]: string 2
After: 
Array[0]: string 1
Array[1]: string 2
Array[2]: string 3