[C] how to interpret (int *) in malloc ?

Question

0.00/5 (No votes)

See more:

This one is mostly a simple question.
Malloc funtions return the address to the memory a user has defined (the size of the memory).

So if it gives the address, it acts like &x when we have int x = 5 in which malloc is like &x and its access to that memory is like int x = 5.

What I have tried:

Fistly, I've checked if there is something like Function pointer. And there it was!

C

#include <stdio.h> 
// A normal function with an int parameter 
// and void return type 
void fun(int a) 
{ 
    printf("Value of a is %d\n", a); 
} 
  
int main() 
{ 
    // fun_ptr is a pointer to function fun()  
    void (*fun_ptr)(int) = &fun; 
  
    /* The above line is equivalent of following two 
       void (*fun_ptr)(int); 
       fun_ptr = &fun;  
    */
  
    // Invoking fun() using fun_ptr 
    (*fun_ptr)(10); 
  
    return 0; 
}

And this:

C

#include <stdio.h> 
// A normal function with an int parameter 
// and void return type 
void fun(int a) 
{ 
    printf("Value of a is %d\n", a); 
} 
  
int main() 
{  
    void (*fun_ptr)(int) = fun;  // & removed 
  
    fun_ptr(10);  // * removed 
  
    return 0; 
}

It says that Function pointer works differently that it points to a code not an address.

Although in the second example, what if I use (*fun_ptr)(10); ?
So is (int *) malloc is the same as void (*fun_ptr)(int) = &fun;? By same, I mean is it a Function pointer? Which would be weird on the other hand because if I write (int **)malloc, then it returns the address to a pointer in (int *) malloc, it returns the address to the memory.

Posted 20-Oct-23 4:39am

Member 16116753

Updated 24-Oct-23 11:11am

Deeksha Shenoy

v2

Add a Solution

4 solutions

Solution 3

The previous solutions have given appropriate answers. Here's a macro I use when I have to wade into the malloc/free world. It does two main things - it takes care of the casting needed (since malloc returns a void pointer) and it uses calloc so that the memory allocated is cleared to zeros. Incidentally, that's what the C in the name refers to. Anyway, here it is :

C

#define Allocate(count,type)  (type *)calloc(count,sizeof(type));

and here is how it is used :

C

int * pIntegers = Allocate( 42, int );

In contrast, here is how that would look without the macro :

C

int * pIntegers = (int *)calloc( 42, sizeof( int ) );

As has been stated, calloc and malloc return a void pointer so that must be cast to the type that is needed.

Posted 20-Oct-23 6:54am

Rick York

Comments

Member 16116753 20-Oct-23 13:26pm

Maybe different question. What does it mean it returns a void pointer. If I had int *ptr then I guess ptr is a integer pointer and *ptr is the value I guess.

It is still very weird because because it's like a pointer points to the content of another pointer like this :

int *p;
int *x;
p = x;

Usually I see double pointers like these :

int **p;
int *x;
p = &x;

So I thought the first one is incorrect or rather why then use this int *x when this int will have no meaning because the shift from first example is defined by int *p not int *x. Or in other way because my english might be very bad. From first example if I had

int *p;
char *x;
p = x

and shifter by 1 p + 1 it shift by 4 byte no matter what the x is if it's char or int.
If i had the second example it would have also any matter because the pointer is 8 byte big so shifting it will be correct anytime p = &x; and typing p + 1 will shift by 8 bytes

And so this also means that the malloc has the addres of that pointer so it indicates that &malloc is there because malloc is a pointer.

ehhhh

OriginalGriff 20-Oct-23 14:11pm

It means that the pointer it returns can't be used on either side of an assignment operator unless you cat it to an valid type: void is a "zero length value", or a "null value" if you prefer. Think of how it is used when you define a function that returns a void: it returns nothing at all and trying to return any value at all will throw an error, as will trying to assign the result of the function call to any variable.

Seriously, get a book. You will learn much faster and better that you are asking random questions!

Member 16116753 20-Oct-23 14:50pm

I've got the book k5054 provided so I'll start with it, but I wanted to finish at least this topic (because I feel a bit stressed not understanding it and it can block my understanding of other stuff sorry ;<) and I will give a break. Although I think I will have again a problem same goes with random questions they are related so why is it random ;> ?

also : "It means that the pointer it returns can't be used on either side of an assignment operator unless you cat it to an valid type: void is a "zero length value", or a "null value" if you prefer." means what ? Which part ?
I've given an example, and I wanted to see if my comparison is somewhat correct. But yes while giving a question I just came up with that int * p = (int *)malloc() is similar to int *x = y in which y is int *y. So why even saying that y is a pointer same with malloc why I had to use this (int *) if not normal (int) because saying p + 1 will shift by 4 bytes because of size of(int) from int *p or with the example int *x = y, typing x + 1 will shift always by 4 bytes no matter if y is char *y or float *y it will always shift by 4 bytes. That's weird and doesn't have sense ...

And I think this will block my understanding while reading books it at least blocked my understanding while reading "Understanding and Using C Pointers". I know to read a book and I will do it I just want to finish this topic atleast.

Member 16116753 20-Oct-23 15:49pm

Is it possible to resolve this question ? I know this is chaotic, but I feel if I won't know this I will not understand something during the learning.

Rick York 20-Oct-23 16:44pm

A void pointer is a pointer to data of an unknown type. A double pointer is something different. That is a pointer to another pointer. In a 64-bit program a pointer is eight bytes but in a 32-bit program it is four bytes long.

Malloc doesn't exactly "have the address of a pointer." It obtains a pointer from the heap memory manager and returns that pointer to the caller. There are (at least) two basic types of memory in a program - the heap and the stack. The stack grows and shrinks automatically as functions are called and return. Non-static variables that are local to a function live on the stack. When a function is called the stack grows to accommodate those local variables along with the address to return back to. When the function returns the stack shrinks back to where it was and program execution continues at the return address that was just popped off the stack. The heap is a different piece of memory that is used when memory is allocated by calls to malloc and calloc.

Member 16116753 20-Oct-23 19:01pm

Okey, I read it and read something from book.
Tell me only if I am right when it comes to this topic and that's all :

- if I had int *ptr then &ptr is the address of that pointer, ptr is a pointer to the integer (it's address inside), *ptr is the value the address was pointing to. So (int *)malloc() is the same as : "ptr is a pointer to the integer (it's address inside)"

- The int *p = (int *)malloc() is the same as :

int *p;
int *x;
p = x;

- The type of malloc doesn't really matter in int *p = (int *)malloc() when it comes to arithmetics because if malloc was : (char*)malloc() then typing p + 1 will still shift by 4 bytes becase the pointer is int. But when I want to write a number like 256 into (char*)malloc() it will only save the number 2 in first byte and the rest I think are ingored ? Typing again printf("%d", p) will in result give 2 ? I guess

Solution 4

Take a look at the following code which is an example of using pointers to access a function, an array of characters, and an array of integers. This uses data that is set at compile time, and other data introduced into a block of memory allocated by malloc.

C++

#include <stdio.h>
#include <memory.h>
#include <malloc.h>


// A normal function with an int parameter 
// and void return type 
void fun(int a) 
{ 
    printf("Value of a is %d\n", a); 
} 
  
int main() 
{ 
    char text[] = "Hello, World!"; // an array of characters
    char* cp = text;               // a pointer to characters
    for (; *cp != '\0'; cp++)      // iterate through the character array
    {
        printf("%c", *cp);
    }
    printf("\n\n");

    int numbers[] = { 1, 2, 3, 4, 5, -1 }; // an array of integers
    int* ip = numbers;                     // a pointer to integers
    for (; *ip != -1; ip++)                // iterate through the integer array
    {
        printf("%d, ", *ip);
    }
    printf("\n\n");

    // a function pointer 
    void (*fun_ptr)(int) = fun; 
    // Invoking fun() using fun_ptr 
    fun_ptr(10);
    printf("\n\n");

    //
    // now let's play with malloc
    //
    // note that we capture the address in a void*
    // because we don't care about the content at the moment
    //
    void* vp = malloc(100); // just grab a load of memory

    // calculate the number of bytes in the text string
    int numbytes = (sizeof(text) / sizeof(text[0])) * sizeof(char); // actual length
    // and copy them into our malloc'ed memory. 
    memcpy(vp, text, numbytes); // copy the text into it

    // we can now treat that as a character array
    // by using the correct pointer type
    cp = (char*)vp;           // capture the pointer and cast it to a character pointer
    for (; *cp != '\0'; cp++) // iterate through the character array, as beore
    {
        printf("%c", *cp);
    }
    printf("\n\n");

    // 
    // now do the same with the integers
    //
    numbytes = (sizeof(numbers) / sizeof(numbers[0])) * sizeof(int); // actual length
    memcpy(vp, numbers, numbytes); // copy the numbers into it
    ip = (int*)vp;          // capture the pointer and cast it to an integer pointer
    for (; *ip != -1; ip++) // iterate through the integer array
    {
        printf("%d, ", *ip);
    }
    printf("\n\n");

    //
    // finally let's make it an array of function pointers
    //
    printf("vp = %p\n", vp);
    (void(*)(int))vp = fun;  // set the function address
    ((void(*)(int))vp)(23);  // and execute it.

    // point to the next pointer location
    (char*)vp += sizeof(void(*)(int));
    printf("vp = %p\n", vp);
    (void(*)(int))vp = fun;  // as above
    ((void(*)(int))vp)(45);  // and execute it.

    return 0; 
}

The final two print statements show that the two dynamic function pointers are at different addresses.

Posted 21-Oct-23 0:05am

Richard MacCutchan

Updated 21-Oct-23 0:16am

v4

Comments

Member 16116753 21-Oct-23 6:50am

Very thank you very much. PS.The code didn't work and the last two code "(void(*)(int))vp" are completelly not understandable for me ;D
I've read a bit of that book you've mentioned and some of the stuff has been resolved for me.

I am now experimenting this code and understand how it works :

#include <stdio.h>

int main()
{
    int *x;
    char y = 'd';
    
    x = &y;
    
    printf("%d\n", *x);
    printf("%c\n", *x);
    
    int z, g;
    z = y;
    g = *x;
    
    printf("%d\n", z);
    printf("%c\n", z);
    printf("%d\n", g);
    printf("%c\n", g);

    return 0;
}

Which gives me result of *x being a random decimal number and z being a normal decimal number.
So far I've deduced that %d from *x gives me the 4 byte value from where it points. So whenever I use *x like you did in "if" statement then I will get a decimal number? Like the variable "g" will get a integer from *x. It was just interesting because the z gave me an integer equal to 100, so I thought that it transfered the letter into an integer. And with pointer it did not transfer the letter into an integer. Which is very interesting because why then the pointer doesn't transfer the letter into an int.

PS.2

Although my teory is broken because :

#include <stdio.h>

int main()
{
int *x;
int l = 33;
x = &l;

printf("%d\n", *x);
printf("%c\n", *x);

return 0;
}

It actually shows an letter. So my theory that or reads only the 1st byte is not working ... Hmmmmm I wonder how it works.

Still very very thank you. And sorry for the trouble, because now I feel bad for what I did ;>

Richard MacCutchan 21-Oct-23 7:28am

"the last two code "(void(*)(int))vp"
That is just a cast, telling the compiler to treat vp as something else, e.g.:

int ip = (int*)vp; // tells the compiler to treat vp as if it is an int* - just for this line
(void(*)(int))vp = fun; // tells the compiler to take the address in vp and treat it as if it points to a function, that takes an int parameter, and does not return anything.

But for now, I suggest you stick to pointers to basic types. Function pointers, while useful, are not something you are likely to need very often.

Member 16116753 21-Oct-23 7:33am

Hmmm I still don't quite get it because vp is a variable and it is treated as pointer to the function but I will for now listen your suggestion ;>

So yea now I am working on with the think I showed in the comment. Using the book as well but it didn't answear my question so I am experimenting. But the PS.2 info I added just now destroyed my theory ;> maybe the 33 number is only written in 1 byte at the beggining the the rest are ignored maybe hmmm 33 in bytes hmm

Richard MacCutchan 21-Oct-23 7:44am

Yes, vp is a variable, and is used as a pointer. So it can point to anything you like. In reality it will only ever point to a single byte of memory. It is the designation used by the compiler that tells it how to process whatever data is stored at the location(s) pointed to. So if you say it is a char* then the compiler will generate the instructions necessary to address a single character each time it is used. If you say it is an int* then the compiler will generate the instructions necessary to address 4 or 8* bytes as a single integer value. Similarly if you tell the compiler to use it a a function pointer it will correctly address the number of bytes necessary to hold the address of a function.

*depending on whether you are building 32-bit or 64-bit code.

Richard MacCutchan 21-Oct-23 7:38am

    int *x;
    char y = 'd';
    
    x = &y;
    
    printf("%d\n", *x);

In the above code you have x as a pointer to an int type. You then set it to the address of y which is a char type. So when you try to print what x points to, it tries to print the integer value of 'd', which is 100. Although, because x picks an integer from that location, it will likely include some random values from the next byte locations.

if you change the code to:

    int *x;
    char y[] = "d\0\0\0\0\0\0\0";
    
    x = y;
    
    printf("%d\n", *x);

you should see the correct value.

Member 16116753 21-Oct-23 8:12am

as I thought !!! It read also the random 4 bytes :>
Also I think that "d\0\0\0" should be enough because it is 4 byte as a whole so enough to show the number 100 I guess. I checked it on, and it worked even for "d\0", so I don't know what is the logic how the compilator reads it ;>

Also I've learned how the bytes are putted into memory like number 100 is alloceted this way :

01100100
00000000
00000000
00000000

So the first byte is indeed 100 in integer and the first byte is also a 'd' char. So the same goes with my number 33 which is an int number and a letter.

Or another integer if I had a number 300 then :

00101100 - first byte of 300
00000001 - 2nd byte of 300
00000000
00000000

So the first byte it points to is 00101100 so it is reduced from 300 to 44 so it is now in char "," symbol.

Same goes with string words, that \0 is placed in the first byte so if I read a character from that string it should print \0 (or maybe nothing I don't know how it prints this). Let's say word "OK"

00000000 - \0
1001111 - K
1001011 - O

So if I read the first character from it, it should pop out the \0 ? Because it read from the pointer to this place.

Edit : 
My theory it should print the \0 didn't work. Instead it printed O as a first character hmmm 
There are like 3 chars 1001011 1001111 00000000, and they are placed from top is 00000000 and the last one is 1001011 so it should read 00000000 first hmmmmm. What is my logical error here because I showed the example with 100 and 300 int numbers and how char is picking the first byte so why the first byte is not \0 hmmmm

So the first byte the char is pointing is \0 like tih

In arrays I guess it works differently that the first Character should be O but I think it works differently than pointers.

Uhhhh very interesting. And then I write z = y which z is and normal int and y is a char. Then it converts "d" into 100 and fills the rest with 0. I don't know why but understanding it made me happy ;>

Tell me also if I am right :>

But I also wonder if I have int *x, and write *x it will always return and int number ? I thought for a moment that this int next to a pointer doesn't decide what *x will show because of this printf thing.

Richard MacCutchan 21-Oct-23 8:46am

You are correct about the numbers, but not the characters. Characters are stored in the same way that you read them, so "OK" will be: 'O', 'K', '\0'.

But the real lesson you should learn from this is: don't mix pointers. If you are working with text (i.e. characters) then use char*. If you are working with numbers then use int*. If you use char* to access numbers, or int* to access text, then don't be surprised if you get garbage output.

Member 16116753 21-Oct-23 8:55am

You are totally right!
I should just keep things clear this is why I just tested some of the stuff what is the result.

Okey so strings are stored differently. That's good to know So the first byte is O and not \0 Nice.

I also wanted to know how it works because I see pretty often that the pointer is changed from int to char or to float etc. So I wanted to know if it's okey to do it.

Because if I had an integer pointer like int *x, that is pointing to 4 byte integer, and now it is changed to (float *)x, and type *x it should then appear a random number because now it has to read 8 bytes, which first 4 are the int value and the rest are random I guess. Although I don't know how float numbers are alocated.

Well changing types is also a thing to know. Or perhaps it will work correctly but I don't know yet.

Thank you.

Richard MacCutchan 21-Oct-23 9:07am

No, as I already told you: do not change pointer types. And given all these questions I do not think it is a good idea for you even to consider it.

Member 16116753 21-Oct-23 9:13am

Even in your examples the pointer changed the type ;>
So I thought this is very often used, so maybe the data is changed but I assume that my example with int* x changing into float *x will affect with random number because it read the 8 bytes while he stored at the beggining 4 bytes.

Well that's still some wondering but wanted to see how it works and I saw many examples that changed the type like in yours changes the vp from void to other data. But maybe it is possible because it points to space and not into specific data.
Like changing the int* into char* or putting string value into int like "OK", I guess it will store like you said that 1st byte will be O and goes on and numbers are always stored like I said before no matter what type it shows ??? for Float I don't know yet.

Well so many to test.

Richard MacCutchan 21-Oct-23 10:28am

Yes I was doing this to (try to) show how to use pointers, not to show how to point to the wrong type of data. If you look carefully at my code you will see that in each case I am using the appropriate pointer to refer to the data. It is only in the function section at the end that I use a cast on the void ponter, but I use that cast specifically so it points to the correct data type.

Member 16116753 21-Oct-23 13:14pm

By the way type isn't necessary in malloc as I remember so when "v" points to the malloc then it's type doesn't matter I guess ?

I've tested the void pointer to the malloc without changing the type and putted in char data and it worked.
I think I know what did you mean that it is a good thing to change the type.

Although I want to ask, when can I change the type and when not of a pointer ?
In your example it was more of a changing the type for a pointer to the memory, but if I used "normal pointers" I belive It is not a good idea ?

Richard MacCutchan 21-Oct-23 16:01pm

Yes, the type matters. The pointer type must match the data type that you are accessing. That is why in my samples I use a char*, int* and void(*)(int) to reference the different data types. I really do not understand why you find this difficult.

Member 16116753 21-Oct-23 16:39pm

Well I do have a problem understanding it just by looking at some examples.
Like this one in which the pointer is int but I could read from it a char.

#include <stdio.h>

int main()
{
    int *x;
    int y = 35;
    
    x = &y;
    
    printf("%c\n", *x);

    return 0;
}

Or changing the int pointer to a char pointer and point it to integer, it also works :

#include <stdio.h>

int main()
{
    char *x;
    int y = 35;
    
    x = &y;
    
    printf("%c\n", *x);

    return 0;
}

Or for malloc()

When I type int *x = malloc()
It doesn't matter what type of malloc is whether it is char*, float* arithmetics worked the same which was x + 1 or x + i which is the size of the x type which will be size of int and it is 4 bytes.

#include <stdio.h>
#include <stdlib.h>

int main()
{
int *x = (char*)malloc(5);
x[0] = 33;
x[1] = 34;

printf("%c\n", *x);
printf("%c\n", *(x+1));

return 0;
}

It gave a proper output.
So I was wondering where this type next to pointer is necessary.

I don't really much know how to address my problem with understanding ;D in your example I see the changes wouldn't affect, but in some pointers changing the type will be problematic.

And the example that will give a bad result :

#include <stdio.h>
#include <stdlib.h>

int main()
{
int *x;
int y = 5;
x = &y;

printf("%f\n", *(float*)x);

return 0;
}

Which I partly understand.
Also in your example I don't know what happens if I don't change the type because it points to malloc so maybe nothing ? That's only a speculation, and it came up because malloc doesn't know what it has inside it only give an addres to a space in memory. So passing the addres from malloc to vp and from vp to another pointer then the type shouldn't matter only the type for pointer that takes the addres I guess matters ? Perhaps I am strongly wrong, but that's what I so far deduced reading, testing and watching.

Richard MacCutchan 21-Oct-23 17:04pm

No, you did not read a character. You used an int* to read an integer. You then used that value to print its character representation. In that case you were fortunate that the integer value was in the range of all characters. Try it with some other values and you will get garbage. So I say again: do not do that, as you cannot guarantee what will happen.

This is my last word on the subject.

Member 16116753 21-Oct-23 17:15pm

Well giving a bigger value like 300 also worked, but okey. Same goes with my malloc that had void but was pointed by int and gave a good answear everytime. So I just don't understand why it is wrong.

But I still didn't get an answer to one question. When can I change the type and when not. You've used this type change but in my case it wasn't correct. But that's also my last thing to write after this it will be closed.

Have a nice day and thank you for help :>

Member 16116753 21-Oct-23 9:43am

I've tested it like that :

#include <stdio.h>

int main()
{
int *x;
int y = 16;

x = &y;

printf("%f\n", *(float*)x);

return 0;
}

Result ? It was 0.0000 :> Not really sure how it interprets but welp that's what you said of not changing the type of a pointer (but you've changed it) so I tried to check how it works and figure out why it works like that.

Richard MacCutchan 21-Oct-23 10:25am

You cannot do that, because an integer and a float are stored in totally different ways, which you can research for yourelf. And that is yet another example of why I keep saying: do not do this, unless you fully undestand how data is stored; which you still do not.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2023-10-20T04:55:00

No. Malloc always returns the same type: void * - a pointer to a void.
You can then recast that safely to any type of data pointer you need, it is literally just an address in the data memory area that is allocated dynamically.
Function pointers are different: they only ever point to addresses in the code memory area (which is normally write protected) and the addresses you put in them are not dynamically allocated - they are fixed at link time which is the last process in building an EXE file, and entirely separate from compilation. You cannot cast a function address (or a function pointer) unless the parameters are identical (ie.e you can cast it's return type, but not it's parameter list or types); nor can you do any useful arithmetic with them because functions do not have a defined size at compile time, unlike data types which must.

You can store function addresses in memory, even in blocks allocated by malloc - and you can manipulate them since there have a defined size at compile time, but you can't do anything fancy with the pointers themselves (and you should be very wary of code that does as it's amazingly easy to crash your app if you play with functions pointers or addresses).

Seriously, stop playing and finding random bits and pieces on the internet - get a book or course on C and follow that. Your recent questions show that you really don't understand what is going on, even though I suspect you think you do!

Richard MacCutchan · Accepted Answer · 2023-10-20T05:13:00

Solution 2

The malloc function only ever returns an address of a block of memory, nothing less nothing more. Although it will return NULL if there is no space available. And yes, a function pointer is always the address of the code, so (like an array name) you do not need the & (addressof operator) on it. As to your question, "(int *) malloc is the same as void (*fun_ptr)(int) = &fun;"; no it is not, and the question really makes no sense. You seem to be tying yourelf in knots over pointers and making it far more complicated than it needs to be. As OriginalGriff has already suggested, get yourself a book on C and learn it properly rather than wasting your time with these questions. The best book on the subject is "The C Programming Language" by Kernighan & Richie.

Posted 20-Oct-23 5:13am

Richard MacCutchan

Comments

Member 16116753 20-Oct-23 11:26am

I'm sometimes basing my questions from the books.
I also watch tutorials that starts from the beggining and step by step shows new stuff that also is connected to the last lessons. So I was stuck with pointers and how do they work. Maybe questions are pointless but then what quesitons should I ask ? I am stuck with the tutorials or information from books on website

Richard MacCutchan 20-Oct-23 11:48am

The book I suggested explains pointers in clear detail. And if you work through the book from start to finish, practicing all the suggested code, you will find it easier to understand. And I would avoid videos, as so many are of poor quality.

Member 16116753 20-Oct-23 12:07pm

Hmm I will give it a try, so far I was following "Understanding and Using C Pointers".
But I usually have a problem with pointers that I compare new stuff with old stuff like I showed with malloc because they look similar if not the same but one has (int *) function and the other is int (*function). I have a feeling with new book I will have the same because I very often compare new stuff because mallox acts like &x and the content of malloc is like int x, which is weird because malloc has next to it (int *)

k5054 20-Oct-23 12:32pm

You don't even need to buy it: https://colorcomputerarchive.com/repo/Documents/Books/The%20C%20Programming%20Language%20(Kernighan%20Ritchie).pdf
This book is THE reference for learning C, IMO. I'ts what I used to get started, back in the pre-ANSI days. I'm sure its the go-to book for just about everyone, except perhaps Kernighan and Ritchie themselves

Member 16116753 20-Oct-23 15:40pm

This book contains these type of dilemma like my questions ? And what if doesn't ? Should I ask here or will it be treated like random question ?

OriginalGriff 20-Oct-23 12:35pm

You are going to find that a lot of stuff looks very similar: it often depends on context what it actually means! C uses a very limited set of characters so it ends up using them for different things. As I said the other day, it's a very old language so it shows it's age in many, many ways.

Member 16116753 20-Oct-23 13:50pm

Yes OriginalGriff you are right that this is an old language that's why the pointers are very puzzeling, and that's why I ask stuff like these because (int *) function and int (* function) looked the same.
So I was like okey let's rewind my knowladge. If I have int *ptr then I have a pointer to an integer. Typing ptr will give me the address this pointer points to and typing &ptr I get the address of that ptr.
So if I have (int *) malloc() and malloc returns address to the memory then (int *) malloc() return something like ptr, Why I assumed something like that is because malloc gives the address where it points to like ptr. And if I say &malloc() then it should give me the address of the pointer itself like &ptr. Hence the *ptr gives the content like *(int*) malloc() ?

The thing was with (int *) with a function.

I also remembered something like this example :

int ptr*;
ptr = &x

And there was something like (char *)ptr which changed a bit where the pointer points to and arithmetics changes from sizeof(int) to sizeof(char) when I type ptr+i. So yea I compare many things which I again apologize for taking your time, because I thought this is not as random.

Or I came up with another thing if (int *)malloc() is similar if not the same as ptr (when int *ptr). Then :

int * ptr;
ptr = (int*)malloc();

Feels the same as

int *p;
int *x;
p = x;

Which feel weird Because what will change if I say (char *)x when ptr will shift by 4 bytes anyway. Ehhhhhhh sorry

int *p;
char *x;
p = x

and shifter by 1 p + 1 it shift by 4 byte no matter what the x is if it's char or int.
If i had the second example it would have also any matter because the pointer is 8 byte big so shifting it will be correct anytime p = &x; and typing p + 1 will shift by 8 bytes

And so this also means that the malloc has the addres of that pointer so it indicates that &malloc is there because malloc is a pointer.

OriginalGriff 20-Oct-23 12:31pm

Seconded again!

k5054 20-Oct-23 12:33pm

Too bad we can't up-vote comments ...

OriginalGriff 20-Oct-23 12:35pm

Upvote his solution - I did!

Richard MacCutchan 20-Oct-23 12:48pm

Thanks, Paul. I guess you are (almost) fully recovered from yesterday.

OriginalGriff 20-Oct-23 14:06pm

Pretty close (it was Tuesday I got jabbed) but I still get tired really easily. Getting better each day though.

k5054 20-Oct-23 13:27pm

I already did.

OriginalGriff 20-Oct-23 12:31pm

Seconded!

[C] how to interpret (int *) in malloc ?

4 solutions

Solution 1

Solution 2

Solution 3

Solution 4

Add your solution here

Preview 0

Existing Members

...or Join us