What does the parameter definition in front of the malloc function mean?

This is not a parameter definition, but a forced type conversion. Forcibly converts the memory of the new request to the desired type.

For example: int* p = (int *)malloc(size);

What type of pointer your pointer is, what type of malloc space you apply for will be returned

Malloc returns void*, so it's best to force it to the type you need.

unsigned char maxval() const throw()

unsigned char maxval() const This is a constant function, throw() is an exception description! If the function throws an exception, the exception that is thrown will be one of the ones included in that description! Here, throw() does not specify the type of exception, the function can throw any type of exception!

If you write unsigned char maxval() const throw(runtime error), if the function throws an exception, it will be an object of type runtime error! You can use try to catch exceptions, so you can find out when something went wrong there!

First of all, the function prototype of malloc looks like this, extern void *malloc(unsigned int num bytes);

The return value is void*, which is a pointer of type void, which means that it can be arbitrarily cast to a pointer of other types.

The argument is an unsigned int value, which is passed the size of the static heap you want to apply, in bytes.

The meaning of the function is to request a space the size of your parameters, and return a pointer to this space to you, and you can use this space with this pointer.

thus (int)malloc(sizeof(int)); int)malloc(sizeof(int*))

These two are misspellings, and although grammatically they can be used, few people will use them that way... Unless it's for some special purpose. This is because it is not necessary to cast a pointer to an int type and then use it as a number of int types.

This is usually a cast pointer.

and (int*)malloc(sizeof(int)); int*)malloc(sizeof(int*))

The difference is in sizeof, is int the same size as int*?

If it is a 32-bit compiler, since the sizeof(int) and sizeof(int*) values are both 4, both of which are 4 bytes in size, the result of calling the function is the same.

For a 64-bit compiler, sizeof(int) is 8 and sizeof(int*) is 4, the result is different.

Although the result of the 32-bit machine is the same, there is a difference in the meaning of the representation (writing ** a lot is for others to see), because the former means that the former means to apply for 4 bytes of space as int data, and the latter means to apply for 4 bytes of space as int* data to use, so although the result is the same, it is still necessary to pay attention to the meaning of the representation.

( int *)malloc( sizeof(int) ) This is the correct way to write it, and the rest is all wrong to write!