int size = sizeof(original) / sizeof(char*);

Applying sizeof to a pointer not an array over here. This will not return the size of the string to which it points to. strlen is the one you should look for here. Replace the above line with this (Solution to the size determination)

int size = strlen(original); // better to use `size_t`

Now here what is going on - the string literal is a char array which decays into pointer to the first element and that pointer value is being assigned - over which you applied sizeof. There is no trace of array here. To get the number of elements an array can hold you have to pass the array itself not the pointer.

Another thing is C is pass by value - so here to retain the changes either pass the pointer to the pointer or pass the allocated memory address from the function.

sizeof(char) is 1 so you don't need to write it explicitly - you can simply write

copy = malloc(size + 1);

Code:

stringcpy(original, &copy);

And

void stringcpy(const char* original, char** copy) {

    int size = strlen(original);
    *copy = malloc(size + 1);

    int i;
    for(i = 0; original[i] != '\0'; i++) {
        (*copy)[i] = original[i];
    }
    (*copy)[i] = '\0';
}

I have shown you the solution of the problem by passing the address of the pointer variable to the other function. Alternatively (try it yourself) you can return the allocated memory chunk's address from the function and assign it to the copy. This would also work.

Edit: If you are not allowed to change the function signature then yes it's not possible unless you provide the allocated memory to the copy like you did before in case-1.

The otherway to achieve correct behavior would be to do this

char* stringcpy(const char* original) {

    int size = strlen(original) ;
    char* copy = malloc(size + 1);

    int i;
    for(i = 0; original[i] != '\0'; i++) {
        copy[i] = original[i];
    }
    copy[i]=0;
    return copy;
}

And use it like this

copy = stringcpy(original);

Few things omitted in this answer:

• Always check the return value of malloc - in case it returns NULL you won't dereference it if you put a check of it.

• Don't cast the return type of malloc - char* to void* conversion is implicit.

• Free the dynamically allocated memory when you are done working with it.

Are you looking for something like this:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>    
    int main() {
        int i;
        char input[1000] = "Sample string";
        char *in = malloc(1000 * sizeof(char)); // use dynamic number instead of 1000
        strcpy(in, input);
        for (i = 0; i < 5; ++i) { // intentionally printing the first 5 character
            printf("%c", in[i]);
        }
    }

The output is:

Sampl

Edit: In C++ the cast is required for malloc, so I write:

(char *)malloc(1000 * sizeof(char))

But in C, never cast the result of malloc().

sizeof(char) is always 1. You can simplify your code by eliminating it.

Once you know the size of the string you're about to read, there's no way using scanf(3) to limit the input it reads to the size of the buffer you allocated. In general, we don't rely on the input to describe itself accurately.

In your case, even if the description is accurate, the code isn't: scanf promises to terminate the string read by %s with a NUL character, so your 6-byte input needs a 7-byte buffer to accommodate that NUL. That is one error.

There is a fancy way to get scanf to allocate the string memory for you. Traditionally, though, you'd use getline(3) for that, and strlen(3) to find out how much it read.

As one comment points out, realloc(3) invalidates its first argument, meaning p1 can't be relied on after that call. You really want output to be a separate buffer, into which you'll copy data from p1 and p2.

Once you've allocated your output buffer, though, you may be surprised to learn that sprintf(3) is your friend. One call to that function, with %.*s constructions to limit string output dynamically, and pointer arithmetic on the inputs, will generate what you need.

You could use strdup() to return a copy of a C-string, as in:

#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

stringB = strdup(stringA);
/* ... */
free(stringB);
stringB = NULL; 

You could also use strcpy(), but you need to allocate space first, which isn't hard to do but can lead to an overflow error, if not done correctly:

#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

/* you must add one to cover the byte needed for the terminating null character */
stringB = (char *) malloc( strlen(stringA) + 1 ); 
strcpy( stringB, stringA );
/* ... */
free(stringB);
stringB = NULL;

If you cannot use strdup(), I would recommend the use of strncpy() instead of strcpy(). The strncpy() function copies up to — and only up to — n bytes, which helps avoid overflow errors. If strlen(stringA) + 1 > n, however, you would need to terminate stringB, yourself. But, generally, you'll know what sizes you need for things:

#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

/* you must add one to cover the byte needed for the terminating null character */
stringB = (char *) malloc( strlen(stringA) + 1 ); 
strncpy( stringB, stringA, strlen(stringA) + 1 );
/* ... */
free(stringB);
stringB = NULL;

I think strdup() is cleaner, myself, so I try to use it where working with strings exclusively. I don't know if there are serious downsides to the POSIX/non-POSIX approach, performance-wise, but I am not a C or C++ expert.

Note that I cast the result of malloc() to char *. This is because your question is tagged as a c++ question. In C++, it is required to cast the result from malloc(). In C, however, you would not cast this.

EDIT

There you go, there's one complication: strdup() is not in C or C++. So use strcpy() or strncp() with a pre-sized array or a malloc-ed pointer. It's a good habit to use strncp() instead of strcpy(), wherever you might use that function. It will help reduce the potential for errors.

You need to null terminate your string by appending \0 at the end of string.

encode_data = malloc(6*sizeof(char));
for( i = 0; i < 5; i++)
    encode_data[i] = 'a'; 
encode_data[i] = '\0'; 

You don't need to copy the data when realloc returns a different pointer - that is done for you. In fact it is a mistake because you are copying the data from a source that no longer exists, and twice the quantity that it had! So you only need

data = data_new;

Also this line is wrong

data[len] = '0';

it should be

data[len] = '\0';

and can also write beyond the memory bounds. You should be checking the size again before writing the terminator, or more simply, reallocate the memory when size-1 has been used, because you know you'll be needing that extra byte.

if(len == size - 1) {
    // . . . 
}

Note too that if you are entering characters each separated by a newline then getchar() will read every newline too.

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