If your arrays are not string arrays, use: memcpy(array2, array1, sizeof(array2));

str2 is an array. It cannot appear on the left side of an assignment. You will need to use something like strcpy.

q is a pointer. It is perfectly legal to copy one pointer to another.

You're not allocating enough memory for cleanList. I assume CHARLEN is sizeof(char), which is 1 byte. But the elements of cleanList are char*, which is either 4 or 8 bytes, the allocation is much too small. It should be:

char **cleanList = calloc(arrayLength, sizeof(char *));

The general rule when using malloc or calloc is that the multiplier is always sizeof (T), where T is the destination type with one less *. So if you're assigning to char **, it's sizeof(char *).

In your first snippet you modify the pointer in the loop, so after the loop it will no longer point to the same location returned by the malloc call.

Look at it this way, after the call to malloc the pointer and the memory look like this:

result
|
v
+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+

After the first iteration of the loop it will look like this:

    result
    |
    v
+---+---+---+---+---+---+---+---+---+---+---+---+
| H |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+

And after the loop is done it will look like this

                                                 result
                                                 |
                                                 v
+---+---+---+---+---+---+---+---+---+---+---+----+
| H | e | l | l | o |   | W | o | r | l | d | \0 |
+---+---+---+---+---+---+---+---+---+---+---+----+

The copying is made, but the pointer no longer points to the original position.

[Note: Before the copying, the memory allocated by malloc will not be "empty" or initialized in any way, I just show it like that here for simplicity's sake.]

If you are passing destination previously declared with automatic storage type or as a pointer previously allocated with malloc, calloc or realloc having allocated storage type, and in either case having nchars of storage available, you can implement a fairly robust copy function by simply using snprintf.

Since you are passing the maximum number of characters, including the nul-terminating character as a parameter to your copy function, that dovetails nicely with the size parameter for snprintf. Further, snprintf will insure a nul-terminated string in destination -- even if source is too long to fit in destination. As a benefit, snprintf returns the number of characters copied if there is sufficient storage in destination for source, otherwise it returns the number of characters that would have been copied had destination had sufficient space -- allowing you to determine the number of characters truncated if destination is insufficient to hold your source string.

Before looking at the implementation of copy let's look at a prototype and talk about declaring functions to that they provide a meaningful return, and while up to you, let's also look at the order of parameters and type qualifier for source, e.g.

/* simple strcpy src to dest, returns dest on success and number of chars
 * (including nul-termining char) in nchar, returns NULL otherwise.
 */
char *copy (char *dest, const char *src, size_t *nchar);

If you notice, most string functions return a pointer to the destination string on success (or NULL otherwise) which allows you to make immediate use of the return. Next, while not a show-stopper, most string (or memory in general) copy functions place the destination as the first parameter, followed later by the source. I'm sure either Brian Kerrigan or Dennis Ritchie could explain why, but suffice it to say, most copy function parameters are ordered that way.

Notice also that since you are not modifying the source string in copy, it is best to qualify the parameter as const. The const qualifier is more or less a promise you make to the compiler that source will not be modified in copy which allows the compiler to warn if it sees you breaking that promise, while also allowing the compiler to further optimize the function knowing source will not change.

Finally notice your size or my nchar is passed as a pointer above instead of an immediate value. Since a function in C can only return a single value, if you need a way to get a second piece of information back to the caller, pass a pointer as a parameter so the value at that address can be updated within the function making the new value available to the calling function. Here you return a pointer to dest (or NULL) to indicate success/failure while also updating nchar to contain the number of characters in dest (including the nul-terminating character as you passed in a size not a length).

The definition of copy is quite short and simplistic. The only requirement is the source and destination strings not overlap. (neither strcpy or snprintf are defined in that case). The basic flow is to validate both src and dest are not NULL, then handle the case where src is the "empty-string" (e.g. 1st character is the nul-character) and then to copy src to dest using snprintf saving the return in written and then using a simple conditional to determine whether truncation occurred (and warning in that case) and concluding by updating the value pointed to by nchar and returning dest, e.g.

/* simple strcpy src to dest, returns dest on success and number of chars
 * (including nul-termining char) in nchar, returns NULL otherwise.
 */
char *copy (char *dest, const char *src, size_t *nchar)
{
    if (!src || !dest) {    /* validate src & dest not NULL */
        fputs ("error: src or dest NULL\n", stderr);
        return NULL;        /* return NULL on error */
    }

    if (!*src)  /* handle src being an "empty-string" */
        *dest = 0, *nchar = 0;

    int written = snprintf (dest, *nchar, "%s", src);   /* call snprintf */

    if ((size_t)written + 1 > *nchar) { /* handle truncated case */
        fprintf (stderr, "warning: dest truncated by %zu chars.\n",
                (size_t)(written + 1) - *nchar);    /* warn with count */
    }
    else     /* src fit in dest, set nchar to no. of chars in dest */
        *nchar = (size_t)(written + 1); /* including nul-character */

    return dest;     /* return dest so available for immediate use */
}

Putting it altogether in a short example that takes the string to copy as the first argument to the program (using "source string" by default if no argument is given), you could do something like the following:

#include <stdio.h>

#define MAXC 16     /* constant for destination length */

/* simple strcpy src to dest, returns dest on success and number of chars
 * (including nul-termining char) in nchar, returns NULL otherwise.
 */
char *copy (char *dest, const char *src, size_t *nchar)
{
    if (!src || !dest) {    /* validate src & dest not NULL */
        fputs ("error: src or dest NULL\n", stderr);
        return NULL;        /* return NULL on error */
    }

    if (!*src)  /* handle src being an "empty-string" */
        *dest = 0, *nchar = 0;

    int written = snprintf (dest, *nchar, "%s", src);   /* call snprintf */

    if ((size_t)written + 1 > *nchar) { /* handle truncated case */
        fprintf (stderr, "warning: dest truncated by %zu chars.\n",
                (size_t)(written + 1) - *nchar);    /* warn with count */
    }
    else     /* src fit in dest, set nchar to no. of chars in dest */
        *nchar = (size_t)(written + 1); /* including nul-character */

    return dest;     /* return dest so available for immediate use */
}

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

    char *src = argc > 1 ? argv[1] : "source string",
        dest[MAXC];
    size_t n = MAXC;

    if (copy (dest, src, &n))
        printf ("dest: '%s' (%zu chars including nul-char)\n", dest, n);
}

(note: the maximum number of characters in dest is kept short intentionally to easily show how truncation is handled -- size as appropriate for your needs)

Example Use/Output

$ ./bin/strcpy_snprintf
dest: 'source string' (14 chars including nul-char)

Showing maximum number of characters that can be copied without warning:

$ ./bin/strcpy_snprintf  123456789012345
dest: '123456789012345' (16 chars including nul-char)

Showing handling source too long for destination:

$ ./bin/strcpy_snprintf  1234567890123456
warning: dest truncated by 1 chars.
dest: '123456789012345' (16 chars including nul-char)

Look things over and let me know if you have further questions. There are at least a dozen different ways to approach a string copy, but given you are passing dest with its own storage and passing the maximum number of characters (including the nul-character) as a parameter, it's hard to beat snprintf in that case.

strcpy takes pointers to characters and not characters, what you could do is

void copyElement(int n, char source[100])
{
    char * s = (char *) malloc (1) ;
    strcpy(s, &source[n]);
}