One '' '' character. There are some trivial differences having to do with the distinction between a pointer to a constant, and a constant pointer, but since you can cast either to a (char *) it hardly matters. Can I declare main as void, to shut off these annoying ''main returns no value'' messages? (I'm calling exit(), so main doesn't return.) Certainly. You can also declare it as double.

The first two are interchangeable; they declare a pointer to a constant character (you can't change any pointed-to characters). char * const p declares a constant pointer to a (variable) character (i.e. you can't change the pointer).

The first declares an initialized and modifiable array; the second declares a pointer initialized to a not-necessarily- modifiable constant string.

Why can't I convert a char * to a const char *&? The most common response/solution we've seen offered with respect to this issue is that the person with this problem should just use a cast. Unfortunately, there is normally no additional explanation of the matter. So, that's not helpful in understanding the matter. Worse, it can even be considered harmful advice. The second most common response is a blunt "because", but that doesn't help any either.

You can use a pointer-to-T (for any type T) where a pointer-to-const-T is expected. However, the rule (an explicit exception) which permits slight mismatches in qualified pointer types is not applied recursively, but only at the top level. (const char ** is pointer-to-pointer-to-const-char, and the exception therefore does not apply.) The reason that you cannot assign a char ** value to a const char ** pointer is somewhat obscure.

Latest Answer: Hello ppl,i think u all r got confused with this char and varchar.here is itchar : will allocate val...

quot;const Fred* p" means that the Fred can't be changed via pointer p, but there might be other ways to get at the object without going through a const (such as an aliased non-const pointer such as a Fred*). For example, if you have two pointers "const Fred* p" and "Fred* q" that point to the same Fred object (aliasing), pointer q can be used to change the Fred object but pointer p cannot.

You got lucky, I guess. The memory randomly pointed to by the uninitialized pointer p happened to be writable by you, and apparently was not already in use for anything vital. See also question 11.35.

I've got some code that's trying to unpack external structures, but it's crashing with a message about an ''unaligned access.'' What does this mean? The code looks like this: struct mystruct { char c; long int i32; int i16; } s; char buf[7], *p; fread(buf, 7, 1, fp); p = buf; s.c = *p++; s.i32 = *(long int *)p; p += 4; s.i16 = *(int *)p;

The difference is that the value of a static readonly field is set at run time, and can thus be modified by the containing class, whereas the value of a const field is set to a compile time constant. static readonly is typically used if the type of the field is not allowed in a const declaration, or when the value is not known at compile time.

Why is the preprocessor frowned upon? There are a few problems with #define in C and C++, whether the macro is being used as a named constant or as a function-like entity. Among them include: The preprocessor is effectively a separate language from C or C++, and so at some level the compiler really knows nothing about what happened. In effect, the text substitutions that occur happen before the so-called compiler proper phase is invoked. The debugger, error messages, etc.

While the char type is basic to the Java language, many programmers stumble over Unicode escapes, values and conversions. The first definition should...

Opers with +P cannot be kicked by opers with +p, even if you set +p to be a higher level in the channel than +P. You can give +P different onjoin modes than +p, effectively giving an oper with HighProt (+P) higher privileges (or lower, if you want) than an oper with LowProt (+p).