In short, is there any way I can take in a char *input into a function and modify its original memory address without using something like memcpy from string.h?

Yes, you can. Your function modifyCharArray is doing the right thing. What you are seeing is caused by that fact that

char *test = "Bad";

creates "Bad" in read only memory of the program and test points to that memory. Changing it is cause for undefined behavior.

If you want to create a modifiable string, use:

char test[] = "Bad";

Your program has several errors. Assuming the string length. Not allowing for, or writing , the nul terminator. Not returning the pointer. Using == where you mean =. Trying to return a local variable.

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

char *echanger(char *word) {
    int len = strlen(word);
    int i;
    char *final = malloc(len+1);
    for(i=0; i<=len; i++) {         // include terminator
        if(word[i] == 'e')
            final[i] = 'a';
        else
            final[i] = word[i];
    }
    return final;
}

int main(){
    char a[] = "helle";
    char *news;
    news = echanger(a);
    printf("new string is: %s\n", news);
    free(news);                     // was from malloc
    return 0;
}

Program output:

new string is: halla

dst is allocated in main. To modify that allocation in a function, you can return the new pointer or pass a pointer to pointer. Since you return another pointer, you must pass a pointer to pointer char **dest and make a few changes in the function to accommodate that change.

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

char *my_strcat ( char **dest, const char * src) {
    char *tab = malloc ( sizeof ( char) * (strlen ( *dest) + strlen ( src) + 1));//dereference dest
    if ( NULL == tab)
        return NULL;
    strcpy ( tab, *dest);//dereference dst
    strcat ( tab, src);
    free ( *dest);//dereference dest
    *dest = malloc ( sizeof ( char) * ( strlen ( tab) + 1));//dereference dest
    strcpy ( *dest, tab);//dereference dest
    return tab;
}

int main(int argc, char **argv) {
    char *dst = NULL, *src = NULL, *r = NULL;
    src = malloc ( sizeof ( char) * 100);
    strcpy ( src, "fifty");

    dst = malloc ( sizeof ( char) * 100);
    strcpy ( dst, "four");

    r = my_strcat ( &dst, src);//use address of dst
    printf ( "%s\n", r);
    printf ( "%s\n", dst);

    free ( r);
    free ( dst);
    free ( src);

    return 0;
}

You cannot use character array like that after declaration. If you want to assign new value to your character array, you can do it like this: -

strcpy(message, "bar");

The [] operator binds tighter then the *-operator, so change

*b[0] = 0x12;

to

(*b)[0] = 0x12;

Alternatively change

void changeBuff(unsigned char ** b)
{
  *b[0] = 0x12;
  *b[1] = 0x34;
}

to

void changeBuff(unsigned char * b)
{
  b[0] = 0x12;
  b[1] = 0x34;
}

and instead of calling it like this

  changeBuff(&buf);

call it like this

  changeBuff(buf);

Unrelated to your issue:

• There is no need to cast from/to void-pointers in C.
• sizeof (char) equals 1 by definition.

So this line

unsigned char * buf = (unsigned char *)malloc(sizeof(unsigned char) * 2);

is equal to this

unsigned char * buf = malloc(2);

A more robust version would be

unsigned char * buf = malloc(2 * sizeof *buf);

which would survive changing the type of where buf points to.

I recommend using fgets instead of scanf or your application will crash every time the input is longer than MAX. The scanf is writing over the allocated memory boundaries messing up your stack memory inside the main function. (Of course stdin may still have characters inside of it if the user input is too long and needs to be flushed, but that is another story).

Here is a minimal example:

#include <cstdio>

#define MAX 100

void readFileName(char fileName[]){
    printf("Please enter the new file that you would like to open\n");
    fgets(fileName, MAX, stdin);

    printf("%s", fileName);
}

int main() {
    char fileName[MAX];
    readFileName(fileName);
    printf("Still works here: %s", fileName);
    return 0;
}

If you only need to change existing characters in the string, and the string will be in a variable, and you don't mind the side-effect of your original string being modified, then your solution may be acceptable and indeed easier. But:

• What if you want to get a modified string, but also want to retain the original? To avoid destroying an arbitrary-sized original, you need to malloc space, make a copy, and modify that.

• And what if you want to extend the string? If your change is to add " YOU" to the string, it can't modify the original because there's no space for it--it'll cause a buffer overflow, since there's only 4 bytes allocated for "HEY" (three letters plus the null terminator). Again, the solution involves mallocing space to work with.

Functions that make changes using your technique typically need a size or length parameter to avoid overflowing the array and causing a crash and a potential security risk. But although that avoids the overflow, there's still the question of what happens if there's not enough space: Silently drop some data? Pass back a flag or special value to indicate there wasn't enough space, and expect the caller to handle it? In the long run, it ends up easier to write it right the first time, and malloc/calloc the space and deal with having to free it up later and all that.

1.

name="Messi";

You can´t assign a char array with a string unless at its initialization, which is done with:

char name[]="Ronaldo";

Rather use strcpy() (Header string.h) -> strcpy(name,"Messi"); instead.

Consider that the array name needs to be capable of holding the new-assigned string + the null terminator, which is in this case provided because the string "Ronaldo" has more characters than any of the following. If that would not be the case you have to define name with an appropriate amount of characters or choose a name which is bigger than anyone else or the program would cause an overflow of data in memory.

2.

Note that the switch statement doesn´t make sense if choice is always 0 because you have never read input for choice.

Also the cases to the switch are not enclosed by { and } which should give you a compilation error.

3.

choice is initialized by a character. While this is permissible, it does not make sense in this case and confuses readers of your code. Rather use int choice = 0;

Corrected code:

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

int main(void)
{
   char name[]="Ronaldo";
    int choice=0;

    printf("Select Player\n");
    printf("1.Messi\n2.Suarez\n3.Neymar\n4.Dembele\n5.Muller\n\n");

    scanf("%d",&choice);

    switch(choice)
    {

    case 1:
            printf("\nMessi is Selected");
            strcpy(name,"Messi");

            break;


    case 2:
            printf("\nSuarez is Selected");
            strcpy(name,"Suarez");

            break;


    case 3:
            printf("\nNeymar is Selected");
            strcpy(name,"Neymar");

            break;    

    case 4:
            printf("\nDembele is Selected");
            strcpy(name,"Dembele");

            break;    


    case 5:
            printf("\nMuller is Selected");
            strcpy(name,"Muller"); 
           
            break;               

    default:
            printf("Exit");
            exit(1);
    } 

    printf("\nPlayer changed to %s",name);   
    return 0;
}

Output:

/a.out
Select Player  
1.Messi      
2.Suarez      
3.Neymar             
4.Dembele 
5.Muller 
  
2        // Input from User

Suarez is Selected               
Player changed to Suarez      

The = operator is not defined to copy the contents of one array to another. You either have to copy each array element individually in a loop:

for ( size_t i = 0; i < num_elements; i++ )
  dst[i] = src[i];

or you have to call a library function like strcpy (for arrays that contain strings) or memcpy (for arrays that don't contain strings), which does pretty much the same thing under the hood.

Arrays and array expressions in C are weird compared to other aggregate types like struct or union; as part of that weirdness, array expressions are not allowed to be the target of an assignment operator. Under most circumstances, an expression of type "array of T" is converted, or "decays", to an expression of type "pointer to T" and the value of the expression is the address of the first element of the array.

This isn't arbitrary - Ritchie had a reason for making arrays behave this way - but it doesn't make it any less weird.

As noted, in C a string is an array of characters. So, you can access the individual characters like you access any array. For your task what you need to do is

  char names[100][20];
  //Now this declares 100 strings of size 20 each.
  //To access a single character in the position '4' from string 0 you can write
  printf("%c",names[0][3]);

  //To modify the string in position 'i' you will use 
  names[i][strlen(names[i])-1]='\0';

The last line is very similar to what you have written for a single string.

With the first index 'i' you access the string in that position. and with the second index you access a particular character of that string.

When you write a "string" in your source code, it gets written directly into the executable because that value needs to be known at compile time (there are tools available to pull software apart and find all the plain text strings in them). When you write char *a = "This is a string", the location of "This is a string" is in the executable, and the location a points to, is in the executable. The data in the executable image is read-only.

What you need to do (as the other answers have pointed out) is create that memory in a location that is not read only--on the heap, or in the stack frame. If you declare a local array, then space is made on the stack for each element of that array, and the string literal (which is stored in the executable) is copied to that space in the stack.

char a[] = "This is a string";

you can also copy that data manually by allocating some memory on the heap, and then using strcpy() to copy a string literal into that space.

char *a = malloc(256);
strcpy(a, "This is a string");

Whenever you allocate space using malloc() remember to call free() when you are finished with it (read: memory leak).

Basically, you have to keep track of where your data is. Whenever you write a string in your source, that string is read only (otherwise you would be potentially changing the behavior of the executable--imagine if you wrote char *a = "hello"; and then changed a[0] to 'c'. Then somewhere else wrote printf("hello");. If you were allowed to change the first character of "hello", and your compiler only stored it once (it should), then printf("hello"); would output cello!)