How can i get the sizeof a variable through a function using a pointer as a parameter?
readEachChar(unsigned char * input){
printf("The the size of the string %zu", sizeof(input));
for (size_t i = 0; i < sizeof(input); i++) // currently it show me the size of the pointer (8 bytes)
{
printf("[%x]",input[i]);
}
printf("\n");
}
unsigned char text[] = "thisisalongkindofstring";
int main(){
readEachChar(&text);
return 0;
}
You can't just ask for sizeof(pointer) since you'll get the size of the pointer itself. Instead of that- you can change the function to get the size as parameter:
readEachChar(unsigned char * input, unsigned size)
and send the size from main:readEachChar(&text, sizeof(text));
Another solution is to run over the char until you reach the null - '\0' at the end and count the characters within it- that's what the strlen function does.
For starters the argument expression in this call
readEachChar(&text);
has the type unsigned char ( * )[24]. But the function parameter has the type unsigned char * that are not compatible types.
So the compiler should issue a message.
If you will write
readEachChar(text);
then within the function you should just call the function strlen like
for (size_t i = 0, n = strlen( input ); i < n; i++)
{
printf("[%x]",input[i]);
}
Otherwise if the passed array does not contain a string you have to declare the function with a second parameter that will be assigned with the number of elements in the passed array.
In the line
printf("The the size of the string %zu", sizeof(input));
the sizeof operator will give you the size of the pointer input. It will not give you the size of the object that it is pointing to (which may be the size of the array or the length of the string).
In the function main, the definition
unsigned char text[] = "thisisalongkindofstring";
will make text an array of 24 characters: These 24 characters consist of the 23 actual characters and an extra character for the null terminating character. In C, a string is, by definition, a sequence of characters that is terminated by a null character, i.e. a character with the character code 0.
Therefore, in order to determine the length of the string, you must count every character of the string, until you encounter the terminating null character. You can either do this yourself, or you can use the function strlen which is provided by the C standard library.
Also, it is normal to use the data type char for individual characters of a string, not unsigned char. All string handling functions of the C standard library expect parameters of type char *, not unsigned char *, so, depending on your compiler, mixing these data types could give you warnings or even errors.
Another issue is that this line is wrong:
readEachChar(&text);
The function readEachChar seems to expect the function argument to be a pointer to the first character of the string, not a pointer to an entire array. Therefore, you should write &text[0] instead of &text. You can also simply write text, as this expression will automatically decay to &text[0].
After applying all of the fixes mentioned above, your code should look like this:
#include <stdio.h>
#include <string.h>
void readEachChar( char * input )
{
size_t len = strlen( input );
printf( "The size of the string: %zu\n", len );
for ( size_t i = 0; i < len; i++ )
{
printf( "[%x]", input[i] );
}
printf("\n");
}
int main()
{
char text[] = "thisisalongkindofstring";
readEachChar( text );
return 0;
}
This program has the following output:
The size of the string: 23
[74][68][69][73][69][73][61][6c][6f][6e][67][6b][69][6e][64][6f][66][73][74][72][69][6e][67]
How can i get the sizeof a variable through a function using a pointer as a parameter?
printf("The the size of the string %zu", sizeof(input)); does print the size of the variable input, which is a pointer. Apparent OP wants the size of something else such as the size of text[].
To get the size of an object, pass that size into to function.
void foo_sz(size_t sz) {
printf("Size: %zu\n", sz);
}
// Call
foo_sz(sizeof text);
To get the size of an object and the address of the object, pass both.
void foo_both(size_t sz, void *ptr) {
printf("Size: %zu\n", sz);
printf("Ptr: %p\n", ptr);
}
// Call
foo_both(sizeof text, text);
To get the sizeof a variable through a function using a pointer as a parameter, prototype per the type
// 123456789012345678901234
// "thisisalongkindofstring"
void foo_1(unsigned char (*ptr)[24]) {
printf("Size: %zu\n", sizeof *ptr);
printf("Ptr: %p\n", (void *) ptr);
}
// Call
foo_1(&text);
Of course now code loses a generic aspect, but does meet the goal of "sizeof a variable through a function using a pointer".
Alternatively consider using a macro to call with 1 argument yet pass both size and address.
#define FOO_M(obj) foo_both(sizeof(obj), &(obj))
// Call
FOO_M(text);
Additional concerns exists if obj is a VLA or an expression.
