Steve Graegert wrote:
On 9/9/05, _z33 <[EMAIL PROTECTED]> wrote:
Steve Graegert wrote:
char *s;
int *i;
s = (int *)malloc(128 * sizeof(char));
i = (char *)malloc(128 * sizeof(int));
s = "malloc is cool!";
printf("s: %s\n", s);
printf("s: %d\n", s);
i = "malloc is cool!";
printf("i: %s\n", i);
printf("i: %d\n", i);
This piece of code prints:
s: malloc is cool!
s: 4350328
i: malloc is cool!
i: 4350328
The illustration was too simple and good, for me to understand.
Thanks :)
You see, casting changes the interpretation of bits when they are
read. The assigment of a particular type to a variable of another
type destroys the original type information (i.e. loss of precision).
destroys the original type information? Couldn't understand this part.
You are still able to recover the string, regardless of what kind of
datatype you store in. The only disadvantage I that, this obscures the
logic of the program.
Didn't mean this specific example, but when casting a float or double
to int then you loose some information which can not be restored
afterwards.
Yes function pointers are legal. ANSI C99 says:
"J.5.7 Function pointer casts
1 A pointer to an object or to void may be cast to a pointer to a
function, allowing data to be invoked as a function (6.5.4).
2 A pointer to a function may be cast to a pointer to an object or to
void, allowing a
function to be inspected or modified (for example, by a debugger) (6.5.4)."
A function name is just a pointer to the memory location where the
function is found at runtime. It can be queried, modified and cast to
other types. It behaves like a variable. Take a look at the
sigaction structure:
struct sigaction {
/* SIG_DFL, SIG_IGN or pointer to function */
void (*sa_handler)(int);
... /* some other fields */
};
You can define sigaction as follows:
void handler(int signo) {
doneflag = 1;
}
struct sigaction sa;
sa.sa_handler = handler;
...
Here, sa_handler is registered as a function to be called when the
specified signal occurrs.
Just handle function pointers as simple pointer variables.
Have still one silly question ---
since you say function pointers are similar to simple pointer
variables, and that's why the typecast works, what would the following
code mean?
void handler1 (int a) {
/* body of handler - 1 */
printf ("HANDLER - 1 \n");
}
void handler2 (int a) {
/* body of handler - 2 */
printf ("HANDLER - 2 \n");
}
struct sigaction sa;
sa.sa_handler = (handler2 *) handler1;
Is this possible? if so, what does it mean?
In this case you are trying to cast to a __name__ rather than a type.
If you write
sa.sa_handler = (void *)handler1;
it would be OK, but nothing would happen. Why? Because no
typecasting takes place (handler1 is of type void already) and
therefore nothing changes. handler1 would be associated to
sa_handler.
hmm.. fine
A final example:
.."final"..
Got scared seeing this :-O
my silly questions are annoying you???
#include <stdio.h>
void func1(int);
void func2(int);
void func1(int i) {
printf("func1: %d\n", i);
}
void func2(int i) {
printf("func2: %d\n", i);
}
int main (void) {
void (*f1)(int) = (void *)func1;
/* the same as above */
void (*f1)(int) = func1;
void (*f2)(int) = func2;
f1(1);
f2(2);
getc(stdin);
return (0);
}
Everything fine now?
yes :)
_z33
--
I love TUX; well... that's an understatement :)
-
To unsubscribe from this list: send the line "unsubscribe linux-c-programming"
in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
