When you declare an array like a[] = {...} the array gets a fixed size which cannot be altered, the size is determined when you compile.

If you want to use dynamic arrays you need to allocate on the heap, in C this is done with malloc and realloc. realloc allows you to resize an array.

e.g.

char* p = malloc(10);
char* q = realloc(p, 5); // now you made the array 5 bytes shorter

you should check the return value of realloc in order to know whether the realloc was successful.

char* q = realloc(p, 5);
if (q != NULL) // successful

ref: https://en.cppreference.com/w/c/memory/realloc

Use strncpy:

char chararray[6];
(void)strncpy(chararray, "abcdefgh", sizeof(chararray));

You need to declare file so it's large enough to hold newFile.

char file[127] = "/home/jack/files/data.txt";

Then when you want to update it, you use:

strcpy(file, newFile);

For your specific case where you initially have 0 and 1, the following might be faster. You'll have to bench mark it. You probably can't do much better with plain C though; you may need to dive into assembly if you want to take advantage of "x86 trickery" that may exist.

for(int i = 0; i < size ; i++){
  array[i] *= 123456;
}

EDIT:

Benchmark code:

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

size_t diff(struct timespec *start, struct timespec *end)
{
  return (end->tv_sec - start->tv_sec)*1000000000 + end->tv_nsec - start->tv_nsec;
}

int main(void)
{
  const size_t size = 1000000;
  int array[size];

  for(size_t i=0; i<size; ++i) {
    array[i] = rand() & 1;
  }

  struct timespec start, stop;

  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
  for(size_t i=0; i<size; ++i) {
    array[i] *= 123456;
    //if(array[i]) array[i] = 123456;
  }
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &stop);

  printf("size: %zu\t nsec: %09zu\n", size, diff(&start, &stop));
}

my results:

Computer: quad core AMD Phenom @2.5GHz, Linux, GCC 4.7, compiled with

$ gcc arr.c -std=gnu99 -lrt -O3 -march=native

• if version: ~5-10ms
• *= version: ~1.3ms

The problem is in the printing part,

 printf("%c", arr);

You cannot print the whole arr using %c. You need a loop to do that, element by element.

You can re-use the same loop conditions which you've used for initialization of the elements at the very beginning to print out the modified array.

FWIW, arr is not the correct type expcted by %c and this invokes undefined behaviour.

sptr=malloc(sizeof(char*)*nStrings);

for(i=0;i<nStrings;i++)
{
    scanf("%s",string);
    sptr[i]=strdup(string);
}

I assume the variable string has enough memory to keep the read strings.

The error occured because you set the pointer to point to the string variable.

As a pointer is referencing an object you can change that object by dereferencing the pointer. It does not matter where this object is (of course if the object exists - which is a problem when you return a pointer to the automatic storage duration).

im using call by value and not by reference, can you explain this to me please?

No, you pass reference to the first element to the array c defined in main. Arrays are not passed by value!!!

To avoid confusion change the function declaration to:

int *fun(int x,int y, int *c)

And also, if i change the line of code "return &c[0];" for this line of code "return &x;" i dont get a warning in the first statement but i get a warning in the second, why does this happens?

because you return reference to the first element of array c defined in function main which is not local to the function fun

You're not storing strings you're storing characters so all you can read is one character so that'd be the S

My suspision is that the next character is an O so when you look at it as a string you get SO

printf("'%c'", items[i][j]);

It's an array of values, not of pointers. So you'd just do

array[5] = MyType();

This requires MyType to support the assignment operator.

Incidentally, there's rarely a need for manual array allocation like this in C++. Do away with the new and delete and use std::vector instead:

std::vector<MyType> array(10);
array[5] = MyType();

Note, there's no need to delete anything.