Expected ‘const char * restrict’ but argument is of type ‘int’

I saw few threads about it but still no clue how to fix that error. The thing is:

    char *data;
    char chat;  
    snprintf(chat,"%d",getc(file));//error here
    printf("\Variable %c",chat); // here is still valid
    strncpy(data, chat, SHM_SIZE); //error here

Please help 🙂

sprintf – gives error (int to char conversion);
atoi/itoa – not working :/

Edit: @iharob
thank you! i still have a problem….

   strncpy(data, "a", SHM_SIZE); //is totally working

but

 char chat[SHM_SIZE];  
    snprintf(chat, sizeof chat, "%d",getc(file));
    printf("Variable %c\n", chat);//showing nothing or some weird signs

weird because

printf("Character : %c",getc(file)); //shows everything ok

Best Answer

This could be done with the following

char *data;
char chat[SHM_SIZE];  

/* snprintf signature is snprintf(char *str, size_t size, const char *format, ...); */
/* read the manual please */
snprintf(chat, sizeof chat, "%d",g etc(file));
printf("Variable %s\n", chat); // here is still valid

length = strlen(chat);
/* you need to allocate space for the destination */
data = malloc(1 + length); /* 1+ for the terminating null byte which strlen does not count */
if (data != NULL) /* check that malloc succeeded. */
    strncpy(data, chat, length); //error here

please read the snprintf manual

Related Solutions

The difference between char * const and const char *

The difference is that const char * is a pointer to a const char, while char * const is a constant pointer to a char.

The first, the value being pointed to can't be changed but the pointer can be. The second, the value being pointed at can change but the pointer can't (similar to a reference).

There is also a

const char * const

which is a constant pointer to a constant char (so nothing about it can be changed).

Note:

The following two forms are equivalent:

const char *

and

char const *

The exact reason for this is described in the C++ standard, but it's important to note and avoid the confusion. I know several coding standards that prefer:

char const

over

const char

(with or without pointer) so that the placement of the const element is the same as with a pointer const.

C++ – the difference between const int, const int const, and int const *

Read it backwards (as driven by Clockwise/Spiral Rule):

int* - pointer to int
int const * - pointer to const int
int * const - const pointer to int
int const * const - const pointer to const int

Now the first const can be on either side of the type so:

const int * == int const *
const int * const == int const * const

If you want to go really crazy you can do things like this:

int ** - pointer to pointer to int
int ** const - a const pointer to a pointer to an int
int * const * - a pointer to a const pointer to an int
int const ** - a pointer to a pointer to a const int
int * const * const - a const pointer to a const pointer to an int
...

And to make sure we are clear on the meaning of const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.

foo is a variable pointer to a constant integer. This lets you change what you point to but not the value that you point to. Most often this is seen with C-style strings where you have a pointer to a const char. You may change which string you point to but you can't change the content of these strings. This is important when the string itself is in the data segment of a program and shouldn't be changed.

bar is a constant or fixed pointer to a value that can be changed. This is like a reference without the extra syntactic sugar. Because of this fact, usually you would use a reference where you would use a T* const pointer unless you need to allow NULL pointers.

Best Answer

Related Solutions

The difference between char * const and const char *

C++ – the difference between const int*, const int * const, and int const *

Related Topic

C++ – the difference between const int, const int const, and int const *