You can't directly do array2 = array1, because in this case you manipulate the addresses of the arrays (char *) and not of their inner values (char).

What you, conceptually, want is to do is iterate through all the chars of your source (array1) and copy them to the destination (array2). There are several ways to do this. For example you could write a simple for loop, or use memcpy.

That being said, the recommended way for strings is to use strncpy. It prevents common errors resulting in, for example, buffer overflows (which is especially dangerous if array1 is filled from user input: keyboard, network, etc). Like so:

Copy// Will copy 18 characters from array1 to array2
strncpy(array2, array1, 18);

As @Prof. Falken mentioned in a comment, strncpy can be evil. Make sure your target buffer is big enough to contain the source buffer (including the \0 at the end of the string).

A C string is a nul-terminated character array.

The C language does not allow assigning the contents of an array to another
array. As noted by Barry, you must copy the individual characters one by one
from the source array to the destination array. e.g. -

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

int main()
{
    char str1[] = "Hello";
    char str2[10] = {0};

    for (int x = 0; x < strlen(str1); ++x)
    {
        str2[x] = str1[x];
    }

    printf("%s\n", str2);

    return 0;
}

To make this common task easier there are standard library functions provided
which will perform this operation. e.g. - memcpy(), etc.

memcpy(str2, str1, 6);

When the array contains a nul-terminated string of characters you can use
strcpy(), etc.

strcpy(str2, str1);

Caveat: Some of the above functions are considered unsafe as they do not guard
against buffer overruns of the source and destination arrays. There are safer
versions provided by the compiler.

Note that if and when you start learning C++ you will find that there you can
assign a C++ std::string object to another object of the same type. However,
even in C++ the same rules apply when working with C strings, "raw" character
arrays, etc.

• Wayne

Use strcpy(), strncpy(), strlcpy() or memcpy(), according to your specific needs.

With the following variables:

const char *tmp = "xxxx";
char buffer[50];

You typically need to ensure your string will be null terminated after copying:

memset(buffer, 0, sizeof buffer);
strncpy(buffer, tmp, sizeof buffer - 1);

An alternative approach:

strncpy(buffer, tmp, sizeof buffer);
buffer[sizeof buffer - 1] = '\0';

Some systems also provide strlcpy() which handles the NUL byte correctly:

strlcpy(buffer, tmp, sizeof buffer);

You could naively implement strlcpy() yourself as follows:

size_t strlcpy(char *dest, const char *src, size_t n)
{
    size_t len = strlen(src);

    if (len < n)
        memcpy(dest, src, len + 1);
    else {
        memcpy(dest, src, n - 1);
        dest[n - 1] = '\0';
    }

    return len;
}

The above code also serves as an example for memcpy().

Finally, when you already know that the string will fit:

strcpy(buffer, tmp);

use strncpy() rather than strcpy()

/* code not tested */
#include <string.h>

int main(void) {
  char *src = "gkjsdh fkdshfkjsdhfksdjghf ewi7tr weigrfdhf gsdjfsd jfgsdjf gsdjfgwe";
  char dst[10]; /* not enough for all of src */

  strcpy(dst, src); /* BANG!!! */
  strncpy(dst, src, sizeof dst - 1); /* OK ... but `dst` needs to be NUL terminated */
      dst[9] = '\0';
  return 0;
}

First off struct employee* emps[maxemps]; creates an array of pointers to struct employee with array size maxemps. You haven't actually set aside any space in memory for the actual structs, just the pointers that will point to them. To dynamically allocate space on the heap for your structs so you can use them in a meaningful way, you'll need to loop over a call to malloc() like so:

for (i = 0; i < maxemps; i++) {
   emps[i] = malloc(sizeof(struct employee));
}

You'll also want a similar loop at the end of your program which will free() each pointer.

Next, when you are getting input from a user you really want to be using fgets() over scanf() because fgets() allows you to specify the number of characters to read in so you can prevent overflows on your destination buffer.

Update

If you want to work with a single struct employee without the use of pointers this is accomplished by declaring one or more struct employee on the stack and then using the . member access operator as follows:

struct employee emp;
fgets(emp.lastname, sizeof(emp.lastname), stdin);

Update2

I found a number of errors in your code. Please see this link for a working sample with comments.

Simplest way I can think of doing it is:

string temp = "cat";
char tab2[1024];
strcpy(tab2, temp.c_str());

For safety, you might prefer:

string temp = "cat";
char tab2[1024];
strncpy(tab2, temp.c_str(), sizeof(tab2));
tab2[sizeof(tab2) - 1] = 0;

or could be in this fashion:

string temp = "cat";
char * tab2 = new char [temp.length()+1];
strcpy (tab2, temp.c_str());

we simply use the strcpy function to copy the array into the pointer.

     char str[] = "Hello World";
     char *result = (char *)malloc(strlen(str)+1);
     strcpy(result,str);

This is exactly what std::string's copy function does.

#include <string>
#include <iostream>

int main()
{

    char test[5];
    std::string str( "Hello, world" );

    str.copy(test, 5);

    std::cout.write(test, 5);
    std::cout.put('\n');

    return 0;
}

If you need null termination you should do something like this:

str.copy(test, 4);
test[4] = '\0';