Printable View
It's completely different types.
var is float*, so if you dereference is, you get float. Yet radius is float, so if you take its address, you get float*, and assigning float* to float doesn't work, unless you do a cast.
However, an array (1D ONLY!) is automatically converted to a pointer when you pass it to a function requiring a pointer.
So array becomes int* and the function wants int*, so it's fine.
this makes sense ...Quote:
Originally Posted by Elysia
i dld the Dev C++ and i uninstalled the VC++.
for what you said about the %p and that the main should start with int i checked the whole book and didnt find a main starting with int and the %p while printing a pointer.
by the way im using the teach yourself C in 21 days for sams.should i switch to another book ?:confused:
I know little about books, but books can be wrong too, you know. Always return int from main and pointers aren't supposed to be printed with %d. For C++, it's %p, I don't know if it holds for C, however. But there are resources where you can check.
in the second sample there is also error in the function prototype
ill think about that.
anyways thank you for all your help
Yeah, as I mentioned before, all function definitions and declarations should match, no exceptions. The compiler takes a look at the prototype when compiling, so if you type int there it will think it accepts int instead of int* as you have it in the definition.
I think you're getting confused between initializing and assignment. The variable declarationQuote:
Originally Posted by BlaX
is the same as the codeCode:float *var = &radius;
The variable is var, not *var; the type is float * (i.e., pointer-to-float), not float.Code:float *var;
var = &radius;
Which is why I always do type* var instead of type *var!Quote:
Originally Posted by tabstop
Makes it easier to distinguish type from variable. Type is type* and variable name is var!
how should i know all these if they arent mentioned in the book !... this book sucks
I would be really surprised if a statement such as "the variable declaration float *var defines a variable named var, which holds the address of a float variable" does not appear anywhere in the chapter.Quote:
Originally Posted by BlaX
i read the whole chapter,but it doesnt say anywhere that there is a type float *.i thought the type was just float till Alysia said that the type is float *.Quote:
Originally Posted by tabstop
anyway.i was wondering whats the difference of starting a main() with int or without it ?
Yes, the type is a pointer to float, hence why I say the type is float*. Because it's a pointer that points to a value of float.
However, there's nothing that says the type is float*. You can write it as float* var, float * var, float *var, as you wish. It's the mindset of which is easier. I find float* var easiest as it tells me that var is a variable of float*, a pointer to float.
For the second question... In C, all functions that lack a return type are automatically considered to return int. This is frowned upon by many upon the boards who like to explicitly specify the return type.
It can also be confusing because you may think the function returns nothing. But this is not the case. It implicitly returns int. Which is even worse, because in C you can omit a return for functions and then the return type will be undefined.
So you may think the function returns nothing, and you omit the return, and thus the return is undefined.
In C99, main is required to return int. In C++, all functions must have a return type and return something, so just omitting return type is, at the very least, not a good practice.
I can't find the C version in the library, just the C++ version, but it says this:Quote:
Originally Posted by BlaX
As to the other, every program returns an exit code to the operating system, so your main must return an int.Quote:
Storing a Variable's Address in a Pointer
Every variable has an address. Even without knowing the specific address, you can store a variable's address in a pointer.
Suppose, for example, that howOld is an integer. To declare a pointer called pAge to hold its address, you write
int *pAge = 0;
This declares pAge to be a pointer to an int. That is, pAge is declared to hold the address of an integer.
Note that pAge is a variable. When you declare an integer variable (type int), the compiler sets aside enough memory to hold an integer. When you declare a pointer variable such as pAge, the compiler sets aside enough memory to hold an address (on most computers, four bytes). A pointer, and thus pAge, is just a different type of variable.
Which is why I always do type *var instead of type* var!Quote:
Originally Posted by Elysia
Makes it easier to distinguish type of the dereferenced variable: *var is a type!
:p ;)
Eh... That makes no sense. Why would you want to have more clarity on the dereferenced type? Knowing that the type is type*, then the dereferenced type must be the type - *, so type.
type *var makes you think *var is the name of the variable! :eek:
Or not. Hehehe. It depends on the mindset of each individual. That's why there's always a huge, heated debate whenever the standard wishes to discuss which syntax to use, and I'm guessing, that's why all 3 are in the language :p