Programming

This might be a silly question, but I thought I'd ask anyway. If I'm writing in C, isn't it more efficient to, for instance, use constant character variable set to 'A' instead of hard-coding a character 'A'? Since it's only a single character instead of a string, it might not matter much.

You would still need to somehow initialize the const char variable...unless I'm not reading you correctly. Best if you explained by an example.

const char at_sign = '@';
char str[] = "fred@email.com;
char *ptr;
.
.
.

ptr = strrchr (str, '@');

vs.

ptr = strrchr (str, at_sign);

The statement below is better only due to its generality.

Code:

ptr = strrchr (str, at_sign);

Later on if you wanted to set the at_sign variable to '~' then the change has to made only at one place...saving you a lot of typing; but in the first form all instances of '@' need to be replaced by '~' in all the source files.

Code:

ptr = strrchr (str, '@');

Other than that there is nothing to say that one approach is better or more efficient than the other.

The only other point - char to int promotion. For example, when a char is passed to a function by value, it actually is promoted to an int behind the scenes. There are other instances during arithmetic and boolean operations when a char is promoted to an int, then truncated in the result. See the C99 standards document for more information.
Or see the prototypes in ctype.h for any of the character functions - you'll note the arguments are int.

This means that char may undergo type change behind the scenes - so I'm not sure what you are gaining - if anything - other than as shamrock points out, some generality.

Being careful with const values and writing functions as true 'black boxes' that return nothing but copies of arguments, changing no argument, give rise to idempotent functions. These are FAR easier for the compiler to optimize. Stdc lib example: strlen(). Takes a const char * argument returns size_t.

Following on from shamrock,, I think it's a trade-off and depends on the context and intentions.
If the variable is likely to vary, then

Code:

ptr = strrchr (str, at_sign);

is "better" because it is more general, but means I have to go and look up what the variable is assigned to. So from a readability prespective,

Code:

ptr = strrchr (str, '@');

is "better" because it is clearly self-documenting and sufficient since, in the email address parsing example given, one wouldn't expect to change '@' to anything else.

There is always an element of subjectivity in these arguments, though. Take your pick

Whether it's more efficient depends on the compiler and architecture. If you wanted to find out which is which, you could generate code to execute each code 100000 times, and then see which is more efficient.

Unter Intel architecture, hard-coding is more efficient because the compiler generates machine code in which the character @ is actually embedded into the instruction (implicit data). With the constant character, the compiler might also do this, or it might generate machine code using direct (absolute address) or indirect (relative to the stack) data addressing, both of which are less efficient. However, due to code caching and such, it's very unlikely to make any difference, unless this code is in many different places throughout the program.

Just for kicks, I wrote such programs and here are the run-times. When they finish, I'll post the run-times.