Sizeof vs. Strlen

[Thomas stegen]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

#include <stdio.h>
#include <string.h>

int main(void)
{
char s[20] = "hello";
char *ptr = "hello2";

printf("s: sizeof == %u, strlen == %u\n", sizeof s, strlen(s));
printf("ptr: sizeof == %u, strlen == %u\n", sizeof ptr, strlen(ptr));

return 0;
}

 

[sugaray]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

 

[Dan Pop]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

strlen is seldom used with a string literal as its argument...

Dan

 

[Mark McIntyre]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1',

you don't need the -1

so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

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

int main(void)
{
char* somestr = "hello world";
printf("length is %d or %d\n", sizeof somestr, strlen(somestr));
return EXIT_SUCCESS;
}

 

[Dan Pop]

^^^^^^^^^^^^^^
you don't need the -1

Of course you do, when using the sizeof operator in the OP's context,
and if you want to get the same result as from strlen(S). Then again,
Mark McIntyre is not supposed to understand this...

Dan

 

[Stephen L.]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

sizeof () gives the total storage size of the string
(including the '\0' terminating character)
and is evaluated at compile time. It's argument
(and the resultant value) can never change at run-time.

strlen() gives the length, excluding the '\0'
terminating character, of the string, and is
evaluated at run-time. It's argument, a pointer
to char array, can change at run-time (as well
as the items in the array itself).

Stephen

 

[Guest]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

Strlen is useful for non literal string.

#include <stdio.h>
#include <string.h>
#define STRING "Hello World!"
#define PRINT(S) printf("%s sizeof == %2u, strlen == %2u\n", \
S, sizeof(S), strlen(S));
int main(void)
{
char s[50] = STRING;
char *p = STRING;
PRINT(STRING);
PRINT(s);
PRINT(p);
return 0;
}

Compiled and executed on my machine will output:

Hello World! sizeof == 13, strlen == 12
Hello World! sizeof == 50, strlen == 12
Hello World! sizeof == 4, strlen == 12

- Dario

 

[Default User]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

You answered your own question. It only works string literals or arrays
that are occupied by a string that exactly fills them (including
terminator). Arrays that contain strings shorter than their capacity,
dynamically allocated string buffers, or any string that has been
assigned to a pointer or passed in to a function won't work.




Brian Rodenborn

 

[Martin Ambuhl]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

You are very confused. Consider the following program. Does 'sizeof'
help in any way in determining the length of the string?

#include <stdio.h>
#include <string.h>

int main(void)
{
char foo[BUFSIZ] = "crap";
char *bar = foo;
printf("When bar points to foo containing \"%s\",\n"
" sizeof foo = %lu, strlen(foo) = %lu\n"
" sizeof bar = %lu, strlen(bar) = %lu\n\n",
foo,
(unsigned long) sizeof foo, (unsigned long) strlen(foo),
(unsigned long) sizeof bar, (unsigned long) strlen(bar));
strcpy(foo, "bananas");
printf("When bar points to foo containing \"%s\",\n"
" sizeof foo = %lu, strlen(foo) = %lu\n"
" sizeof bar = %lu, strlen(bar) = %lu\n\n",
foo,
(unsigned long) sizeof foo, (unsigned long) strlen(foo),
(unsigned long) sizeof bar, (unsigned long) strlen(bar));
return 0;
}


When bar points to foo containing "crap",
sizeof foo = 16384, strlen(foo) = 4
sizeof bar = 4, strlen(bar) = 4

When bar points to foo containing "bananas",
sizeof foo = 16384, strlen(foo) = 7
sizeof bar = 4, strlen(bar) = 7

 

[Christian Bau]

You answered your own question. It only works string literals or arrays
that are occupied by a string that exactly fills them (including
terminator). Arrays that contain strings shorter than their capacity,
dynamically allocated string buffers, or any string that has been
assigned to a pointer or passed in to a function won't work.

On most implementations, sizeof ("Hello, world!") - 1 != 13. Usually the
result will be 3 or 7.

 

[Eric Sosman]

On most implementations, sizeof ("Hello, world!") - 1 != 13. Usually the
result will be 3 or 7.

You're saying "most implementations" are broken, then?
Every C implementation I have ever used would get this one
right -- but then, I've used only a small minority of all
C implementations.

 

[Minti]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

The difference is that sizeof is compile time operator, so you can get
length of only "string literlals" rather than "strings" in general.
While your strlen is a function that is called at runtime.

strlen is a general function capable of computing the length of any
string. It could be used against your "manufactured"/"malloced"
strings as effeciently as against string literals or char arrays,
while sizeof can only be used against your string literals.


I would go with sizeof() as it won't involve any runtime costs.

 

[Default User]

On most implementations, sizeof ("Hello, world!") - 1 != 13. Usually the
result will be 3 or 7.

I think you are wrong. Please present some evidence of this. You ARE
aware that sizeof is an operator, not a function?


Here's a test program:

#include <stdio.h>

int main(void)
{
printf ("%u\n", (unsigned int) (sizeof ("Hello, world!") - 1));
return 0;
}


Built and run with Visual Studio:

13
Press any key to continue


Built and run with gcc:

hercules:/home/m196957> gcc -o so so.c
hercules:/home/m196957> ./so
13


I can't imagine how anything else would be produced.



Brian Rodenborn

 

[Martin Dickopp]

On most implementations, sizeof ("Hello, world!") - 1 != 13. Usually
the result will be 3 or 7.

Are you sure? A string literal has type array of char (6.4.5#5), and
when it is operand of the sizeof operator, it is /not/ converted to a
pointer type (6.3.2.1#3).

Martin

 

[Arthur J. O'Dwyer]

On most implementations, sizeof ("Hello, world!") - 1 != 13. Usually the
result will be 3 or 7.

I count three replies so far along the lines of "gee, I think you're
probably wrong." Just for the record: fourteen minus one is thirteen
on every C implementation in existence. It is *never* 3, and it is
*never* 7. Christian's statement was just plain wrong.

-Arthur

 

[CBFalconer]

I count three replies so far along the lines of "gee, I think
you're probably wrong." Just for the record: fourteen minus
one is thirteen on every C implementation in existence. It is
*never* 3, and it is *never* 7. Christian's statement was
just plain wrong.

I think he is suffering from a temporary delusion that the parens
cause the string to be represented by a pointer. We all have
these problems when a cow flies by.

 

[Villy Kruse]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

#include <stdio.h>
#include <string.h>

int main(void)
{
char s[20] = "hello";
char *ptr = "hello2";

printf("s: sizeof == %u, strlen == %u\n", sizeof s, strlen(s));
printf("ptr: sizeof == %u, strlen == %u\n", sizeof ptr, strlen(ptr));

return 0;
}

Another example

#include <stdio.h>
#include <string.h>

void sub(char s[20])
{
printf("s: sizeof == %u, strlen == %u\n", sizeof s, strlen(s));
}


int main(void)
{
char s[20] = "hello, world";

sub(s);

return 0;
}



Villy

 

[Christian Bau]

Are you sure?

I was sure. I was also wrong.

 

[Default User]

I count three replies so far along the lines of "gee, I think you're
probably wrong."

I generally try to avoid the Dan Pop "engage your brain" rhetoric. After
all, I'm not perfect and I appreciate when people are relatively gentle
when my imperfections surface.




Brian Rodenborn

 

[Jack Klein]

hi, it just came up my mind that since we can get the length of any
given string literal S with 'sizeof S-1', so, what's the merit of
library function strlen()'s existence ? thanx in advance for your
instruction.

#include <stdio.h>
#include <string.h>

int main(void)
{
char s[20] = "hello";
char *ptr = "hello2";

printf("s: sizeof == %u, strlen == %u\n", sizeof s, strlen(s));
printf("ptr: sizeof == %u, strlen == %u\n", sizeof ptr, strlen(ptr));

Passing an uncast size_t to printf() to match a conversion specifier
of "%u" is undefined behavior, of course, and just plain doesn't work
on some implementations.