strlen is not allways a good idea to be used

Question

I'm not sure if I chose the right Title, but today I discovered (as a beginner in C) that for me strlen is not always the right decision to be made when I need it.

So I tried the following:

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

 int foo(char *s){
    int len = strlen(s);
    /* code here */
    return len;
 }

int main(void){
    char *name = "Michi";
    int len = foo(name);
    int a = 20, b = 10, c = a - b;

    if(c < len){
        printf("True:  C(%d) < Len(%d)\n",c,len);
    }else{
        printf("False:  C(%d) > Len(%d)\n",c,len);
    }

    return 0;
}

Output:

False: C(10) > Len(5)

But when I compile with "-Wconversion" I get:

program.c:5:19: warning: conversion to ‘int’ from ‘size_t’ may alter its value [-Wconversion]
         int len = strlen(s);
                   ^

A quick fix will be to cast strlen:

int len = (int)strlen(s);

But I was not agree, so I decided that I really need something else, another approach maybe? I tried the following:

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

unsigned int size(char *s){
    unsigned int len;
    /* code here */
    len = (unsigned int)strlen(s);

    return len;
}

int main(void){
    char *name = "Michi";
    unsigned int len = size(name);
    int a = 20, b = 10, c = a - b;

    if(c < (signed int)len){
        printf("True:  C(%d) < Len(%d)\n",c,len);
    }else{
        printf("False:  C(%d) > Len(%d)\n",c,len);
    }

    return 0;
}

But I still need to cast strlen because of its return type (size_t which I know that is an unsigned type (typedef long unsigned int size_t;))

Finally I decided for another approach, to create my own function, which make things easier and with less possible future problems and I got:

#include<stdio.h>

long int stringLEN(char *s){
    int i = 0;
    long int len = 0;

    while (s[i] != '\0'){
        len++;
        i++;
    }

    return len;
 }

 long int foo(char *s){
    long int len = stringLEN(s);
    /* code here */
    return len;
 }

int main(void){
    char *name = "Michi";
    long int len = foo(name);
    int a = 20, b = 10, c = a - b;

    if(c < len){
        printf("True:  C(%d) < Len(%ld)\n",c,len);
    }else{
        printf("False:  C(%d) > Len(%ld)\n",c,len);
    }

    return 0;
}

where no cast is needed anymore.

So my QUESTION is: is this (for my case) a better approach ? If not I need some explanations, my books (I have 3) does not explain me in that way that I can understand this things.

I know only that at some point cast could be a big problem, somehow.

EDIT: This code will also not compile with -Wconversion:

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

 size_t foo(char *s){
    size_t len = strlen(s);
    /* code here */
    return len;
 }

int main(void){
    char *name = "Michi";
    size_t len = foo(name);
    int a = 20, b = 10, c = a - b;

    if(c < len){
        printf("True:  C(%d) < Len(%zu)\n",c,len);
    }else{
        printf("False:  C(%d) > Len(%zu)\n",c,len);
    }

    return 0;
}

Output:

error: comparison between signed and unsigned integer expressions [-Werror=sign-compare]|

But if I cast len works. I realized that, if the size is bigger then that int it will never fit.

Answer 1

Digging through all the other answers, your true question seems to be how to deal with a situation like this:

#include <string.h>
#include <libfoo.h>

extern void foo(void);
extern void bar(void);

void pick_foo_or_bar(const char *s)
{
   size_t slen = strlen(s);
   int   value = libfoo_api_returning_an_int();

   if (slen > value) // -Wconversion warning on this line
      foo();
   else
      bar();
}

... where you can't change the type of either slen or value, because both are correct for the API they're receiving the result of.

The -Wconversion warning is trying to tell you something meaningful. Comparison of signed and unsigned integer types in C does something very strange, not what you would expect from the laws of arithmetic in ℤ; a naive comparison like what I wrote above can and has caused catastrophic bugs. But the cure is not casts or inventing your own strlen; the cure is to fix the comparison so it does what you expect from the laws of arithmetic. The principles for this are:

• First check whether the signed quantity is negative. If so, treat it as smaller than the unsigned quantity.
• Otherwise, cast the smaller type to the larger type before comparing them.

In this case, size_t is almost certain to be larger than, or the same size as, int, so you would write

#include <assert.h>
#include <limits.h>
#include <string.h>
#include <libfoo.h>

extern void foo(void);
extern void bar(void);

// Code below is correct only if size_t is at least as large as int.
static_assert(SIZE_MAX >= INT_MAX);

void pick_foo_or_bar(const char *s)
{
   size_t slen = strlen(s);
   int   value = libfoo_api_returning_an_int();

   if (value < 0 || (size_t)value < slen)
      foo();
   else
      bar();
}

The static_assert is present because, if I remember correctly, the C standard does not guarantee size_t being at least as large as unsigned int. I could, for instance, imagine an ABI for the 80286 where int was four bytes wide but size_t only two. In that situation you would need to do the casting the other way around:

void pick_foo_or_bar(unsigned short a, long b)
{
    if (b < 0 || b < (long)a)
        foo();
    else
        bar();
}

If you don't know which of the two types is bigger, or if you don't know which of them is signed, your only recourse in standard C is (u)intmax_t:

void pick_foo_or_bar(uid_t a, gid_t b)
{
    if (a < 0 && b < 0) {
        if ((intmax_t)a < (intmax_t)b)
            bar();
        else
            foo();
    } else if (a < 0) {
       bar();
    } else if (b < 0) {
        foo();
    } else {
        if ((uintmax_t)a < (uintmax_t)b)
            bar();
        else
            foo();
    }
 }

... and, given the exceedingly unfortunate precedent set by C99 wrt long, there probably will come a day when (u)intmax_t is not the biggest integer type supported by the compiler, and then you're just hosed.

Answer 2

The lenght of a string can never be negative, whilst an integer could be - the warning is because the range of values for size_t is different to int, and some positive values of size_t would be treated as negative if cast to an int. The better option is to have the return type to your function match, in this case, have foo return a size_t - you'll soon see that the datatype would permiate most of the code, and leave some other oddities that could do odd things (size_t - size_t could underflow...)

Answer 3

This will compile without warnings:

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

 size_t foo(char *s){
    size_t len = strlen(s);
    /* code here */
    return len;
 }

int main(void){
    char *name = "Michi";
    size_t len = foo(name);
    size_t a = 20, b = 10, c = a - b;

    if(c < len){
        printf("True:  C(%zu) < Len(%zu)\n",c,len);
    } else {
        printf("False:  C(%zu) > Len(%zu)\n",c,len);
    }

    return 0;
}

as well explained in the answers and comments by @thomasdickey, @rolandshaw, @andreaghidini, @olaf, @juanchopanza and others.

Did you really made a better approach? No: why should a stringlen function return values that can be negative? There is no such thing as a string with negative size.

The standard strlen function is already there, is more efficient, is able to deal with strings with a maximum size which is twice the maximum size handled by stringLEN, and has a more precise definition of the return type.

Answer 4

There are 2 issues:

1. strlen() returns type size_t. size_t is some unsigned integer type likely as wide or wider than int. It is compiler/platform dependent.

2. Code needs to compare and int to size_t. Since size_t is unsigned, and to prevent a warning of mixed signed/unsigned comparrison, explicitly change int to an unsigned integer. To change an non-negative int to an unsigned integer, cast to (unsigned).

To compare, test if c is negative and if not, then compare (unsigned)c directly to len. Compiler will covert types as needed and result in an arithmetically correct answer.

..

size_t len = strlen("SomeString");
int c = 20;  // some int

if (c < 0 || (unsigned)c < len) puts("c less than len");
else puts("c >= len");

Answer 5

The normal way to solve this is to use variables typed size_t, and choose an appropriate format for printing them. Then no cast is needed. For printf, see these:

• printf format specifiers for uint32_t and size_t
• What's the correct way to use printf to print a size_t?

Answer 6

i think there must be varying from compiler to compiler.....because i tried it on a online compiler and it didn't show any warning.