How to properly initialize a string

How would I go about defining the following string for the following function?

As of now I get the warning:

C4047: '=' : 'const char' differs in levels of indirection from 'char [4]'

and the error:

C2166: l-value specifies const object.

Both in the third line of the code below:

uint8_t *buffer= (uint8_t *) malloc(sizeof(uint32_t));
const char *stringaling= (const char *) malloc(sizeof(uint32_t));
*stringaling = "fun";
newval = protobuf_writeString (buffer, stringaling);

uint32_t protobuf_writeString(uint8_t *out,const char * str)
{

      if (str == NULL)
      {
          out[0] = 0;
          return 1;
      }
      else
      {
          开发者_运维百科size_t len = strlen (str);
          size_t rv = uint32_pack (len, out);
          memcpy (out + rv, str, len);
          return rv + len;
      }
}

const char *stringaling= (const char *) malloc(sizeof(uint32_t));
*stringaling = "fun";

This is not valid code. You are trying to assign to a const variable, which is illegal. Then you are trying to assign an array of characters to a character. And finally, even if you had a non-const array of characters of the right size, you still can't assign arrays, because they're not first-class values.

Try using

char *stringaling = malloc(sizeof(uint32_t));
strcpy(stringaling, "fun");

...instead, and see if that doesn't work better. Note, however, that it's pretty much accidental that (at least usually) sizeof(uint32_t) happens to be the right size to hold "fun". You normally don't want to do that.

Alternatively, you may want:

char const *stringaling = "fun";

or:

char stringaling[] = "fun";

The assignment you had won't work though -- C has only the very most minimal support for strings built into the language; most operations (including copying a string) are normally done via library functions such as strcpy.

"fun" is a string literal, which is essentially a const char *.

stringaling is also a const char *, so your third line is trying to assign a const char * to a const char, which is not going to fly.

If it's a constant string, you can just do this:

const char *stringaling = "fun";

If your input string is dynamic, you can do this:

char *stringaling= (char *) malloc(strlen(inputString)+1);
strcpy(stringaling, inputString);

Obviously, if you malloc it, you need to free it, or feel the wrath of a memory leak.

If you really want to initialize the char *, you could write this instead:

const char *stringaling = "fun";

And here's some reference.

without all the stuff you can also use:

newval = protobuf_writeString (buffer, "fun" );

First problem:

const char *stringaling= (const char *) malloc(sizeof(uint32_t));

Several problems on this line.

First of all, you don't want to declare stringaling as const char *; you will not be able to modify whatever stringaling points to (IOW, *stringaling will not be writable). This matters since you want to copy the contents of another string to the location pointed to by stringaling. Drop the const keyword.

Secondly, malloc(sizeof(uint32_t)) just happens to allocate enough bytes (4) for this particular string, but it's not clear that you meant to allocate 4 bytes. When allocating memory for an array (and strings are arrays), explicitly indicate the number of elements you intend to allocate.

Finally, casting the result of malloc is considered bad practice in C. The cast will suppress a useful diagnostic message if you forget to include stdlib.h or otherwise don't have a prototype for malloc in scope. As of the 1989 standard, malloc returns void *, which can be assigned to any other object pointer type without needing to cast. This isn't true in C++, so a cast is required there, but if you're writing C++ you should be using new instead of malloc anyway.

So, change that line to read

char *stringaling = malloc(LEN); // or malloc(LEN * sizeof *stringaling), but
                                 // in this case that's redundant since 
                                 // sizeof (char) == 1 

where LEN is the number of chars you want to allocate.

The general form for a malloc call is

T *p = malloc (N * sizeof *p);

where T is the base type (int, char, float, struct ..., etc.), and N is the number of elements of type T you want to allocate. Since the type of the expression *p is T, sizeof *p == sizeof(T); if you ever change the type of p, you don't have to replicate that change in the malloc call itself.

Second problem:

*stringaling = "fun";

Again, there are several issues at play. First, you cannot assign string values using the = operator. String literals are array expressions, and in most contexts array expressions have their type implicitly converted ("decay") from "N-element array of T" to "pointer to T". Instead of copying the contents of the string literal, you would be simply assigning a pointer to the first character in the string.

Which would "work" (see below), except that you're dereferencing stringaling in the assignment; the type of the expression *stringaling is const char (char after making the change I indicated above), which is not compatible for assignment with type char *. If you drop the dereference operator and write

stringaling = "fun";

you'd fix the compile-time error, but now you have another problem; as mentioned above, you haven't copied the contents of the string literal "fun" to the memory block you allocated with malloc; instead, you've simply copied the address of the string literal to the variable stringaling. By doing so, you lose track of the dynamically-allocated block, causing a memory leak.

In order to copy the string contents from one place to another, you'll have to use a library function like strcpy or strncpy or memcpy, like so:

strcpy(stringaling, "fun");

If stringaling doesn't need to live on the heap (for example, you're only using it within a single function and deallocating it before returning), you could avoid memory management completely by declaring it as a regular array of char and initializing it with "fun":

char stringaling[] = "fun"; 

This is a special case of initializing an array in a declaration, not an assignment expression, so the = does copy the contents of the string literal to the stringaling array. This only works in an array declaration, however. You can later modify the array with other string values (up to 3 characters plus the 0 terminator), but you'd have to use strcpy again:

strcpy(stringaling, "one");

If you don't need to modify the contents of stringaling, you could just do

const char *stringaling = "fun";

This copies the address of the string literal "fun" to the variable stringaling. And since attempting to modify the contents of a string literal invokes undefined behavior, we do want to declare stringaling as const char * in this case; that will prevent you from accidentally modifying the string literal.