How to get the length of a C-style string using strlen in C

Learn how C measures string length by counting characters up to the terminating null. strlen from string.h is the standard, portable way, while sizeof reports array size and strnlen offers a bounded alternative. We’ll explain why the terminator matters and when other functions appear in real code. This helps you write safer, clearer code and understand type size and portability across platforms.

Multiple Choice

In C, which function returns the length of a C-style string?

Strings, length, and the quiet drama of C’s character array

If you’ve ever peered into a C program and wondered how many characters someone stored in a string, you’re not alone. C strings are a simple idea with a surprising amount of nuance. A C-style string is just an array of chars that ends with a special marker—the null terminator, '\0'. That tiny character is invisible, but it’s the signal that tells a lot of code, “stop here, you’ve reached the end.” The practical upshot is: you can’t rely on the array’s declared size to tell you how many characters the string currently holds. You have to actually walk through the characters until you find that terminator. And that’s where the standard library comes in, offering a few different options to measure.

The straightforward answer: strlen

When you want the length—meaning the count of characters before '\0'—the go-to function is strlen. It lives in string.h and’s been part of C since the dawn of the standard library you reach for when you need to treat a block of memory as text. Here’s the essence: you give strlen a pointer to the first character, and it plods along, counting, until it hits that terminating zero. The return type is size_t, a beloved friend for representing sizes in C. It’s not the same as the array’s total capacity, and it isn’t the number of bytes you might have allocated if the string is stored in a larger buffer. It’s simply how many characters are actually part of the string.

Let me explain with a tiny mental model. Imagine a string as a line of beads on a string, and the terminator is a little bead that says, “Stop here.” The length function doesn’t care about how long the spool is; it cares about how many beads precede that stop bead. That distinction matters, especially in tight memory situations or when you’re juggling multiple strings in an array or a structure.

Why not other options?

There are a couple of other ways people reach for length, and they each have their place, but they can trip you up if you’re not mindful of what they measure.

sizeof(name) is tempting, but it’s not measuring the string’s length. It tells you how much space the array occupies in memory, or how large a pointer has been allocated on some platforms. A string could be short, but if it sits in a big buffer, sizeof might report a much larger number than strlen. Conversely, if you’ve got a pointer rather than a fixed array, sizeof will tell you the pointer’s size, not the string length at all. It’s easy to mix these up, and that’s where a lot of subtle bugs hide.
strnlen(name, n) steps in as a cautious cousin. It stops counting after at most n characters, which is handy when you’re operating on data that might not be properly null-terminated. This can prevent you from wandering past the end of a buffer and causing trouble. The safe-ish vibe of strnlen makes it a good tool in some hands, but it isn’t the universal, portable standard for just knowing how long a string is. If you don’t specify a maximum and you’re certain the string is null-terminated, strlen remains the straightforward choice.
strlen_s, a bounds-checked variant, is the darling of certain environments that emphasize safety. It’s not portable across all C implementations, though. If you’re writing code that needs to travel across compilers and platforms, that lack of portability can bite you later when you try to compile somewhere else.

A practical view: how strlen behaves

Think about how strlen interacts with memory and performance. It has to walk char by char, starting from the first character, until it encounters '\0'. So, its time complexity is O(n), where n is the number of characters before the terminator. In most programs, that’s perfectly fine—humans don’t type terabytes of text in a single line, and modern hardware is fast enough that the usual cost is negligible in the grand scheme of things.

But there’s a nuance worth calling out. If you pass a pointer that doesn’t actually refer to a properly null-terminated string, strlen will wander past the end of the valid memory, looking for a terminator where there may be none, and you’re flirting with undefined behavior. This is where discipline comes in: you either maintain proper invariants about your strings, or you keep them in safe, bounded contexts where you know the data you’re handling is well-formed.

The broader ecosystem: strings as data structures

In C, strings aren’t a separate type with methods attached, like in some higher-level languages. They’re arrays of char with a convention. That simplicity is powerful, but it places a lot of responsibility on the programmer. The length is not stored anywhere by default; you have to compute it or track it yourself.

That’s why you often see a paired pattern: a string buffer with a separate length field, or functions that take explicit lengths alongside pointers. For example, when you’re reading input or concatenating strings, you might keep a separate current length to avoid rescanning the entire string each time you need to know how much space you’ve used. It’s not glamorous, but it’s practical, and it reduces repetitive scans.

A few practical tips you can actually use

Use strlen for simple, readable code when you’re confident the string is properly terminated. It’s the conventional choice and it communicates clearly what you intend.
If you’re dealing with buffers where you know the maximum length, combined usage of strnlen can save you from overreading. The key is to always bound your searches and avoid assuming things about memory you can’t see from the function’s contract.
Be mindful of zero-terminators when you copy strings, not just when you measure them. Functions like strncpy (and its safer relatives in modern practice) can help you keep strings within bounds, but they come with their own quirks. Sometimes, after copying with safe functions, you still need to ensure the string ends with a terminator if the destination buffer is exactly full.
If you’re tempted to treat the pointer as if it carried its length with it, remember: a plain char* doesn’t know its length. You’ll need either a companion length value or a function that computes it when needed.
When portability matters, stick with strlen for length. It’s universally recognized across standard C libraries. If you’re targeting a narrow niche platform, you might explore strlen_s or strnlen, but weigh whether the portability cost is worth the safety benefits.

A nostalgic tangent: the evolution of C string handling

It’s worth pausing to appreciate where strlen sits in the grand timeline of C programming. The original Unix C library needed something lightweight to measure text, and strlen delivered just that—clean, predictable behavior with minimal overhead. Over the years, as software grew more ambitious and safety concerns sharpened their focus, a few extended utilities like strnlen and, in some ecosystems, strlen_s appeared. They reflect a recurring theme in systems programming: add safety, but do it in a way that doesn’t break the fundamental simplicity of the language. The result is a toolbox that’s powerful because you understand its limits, not because it pretends the limits don’t exist.

Stories from the field: where things go wrong, and how to avoid it

I’ve seen folks assume that the size of the array equals the string length more times than I’d like to admit. You declare a char name[256] = "Alice"; sure, but strlen(name) returns 5, not 256. The same logic trips people up when buffers get passed around as function parameters. A function receives a pointer, not a magical sense of how long the string is, unless you explicitly pass the length too. That’s the same thread you’ll see in real-world code: a length parameter, a stable contract, and a careful approach to boundary conditions.

If you’re ever tempted to rely on sizeof to measure length, resist the urge. It’s a birthday gift for the compiler and the debugger, but not a reliable meter for how many characters you’ve typed in a particular string. It’s the size of the storage, not the count of meaningful characters inside that storage.

A cohesive way to think about it

len = strlen(name) gives you the exact number of visible characters before the terminating zero.
sizeof(name) tells you how much space the array has, or the pointer’s binary footprint on some platforms—two fundamentally different notions, easy to confuse.
strnlen(name, n) guards you, stopping at n if there’s no terminator yet. Great for defensive code, less portable as the sole method for length.
strlen_s exists for environments that emphasize bounds-checking, but its portability isn’t guaranteed everywhere.

If you ever write a library that others will use, you’ll likely choose strlen as the default, with strnlen as a defensive option in contexts where you’ve got to be careful about input sizes. It’s all about communicating intent clearly and preventing accidental memory overreads.

A closing reflection: the elegance of a tiny sentinel

The beauty of a C-style string is also its temporary stubbornness. It’s a reminder that even something as simple as “how long is this text?” has depth in a language that gives you so much control—and so much responsibility. The strlen function embodies a quiet elegance: an uncomplicated contract, a straightforward walk through memory, and a result you can depend on when used with proper care.

As you continue exploring systems programming, you’ll encounter many such little anchors—the null terminator, a length field you carry along, or a guard that prevents overreading. They’re the everyday tools that, together, empower you to build robust code without the need for heavy abstractions. And yes, you’ll still encounter the occasional trap—like assuming that the array’s declared size equals the string’s length—but that’s part of the learning curve. With strlen in your toolbox and a mindful approach to how you store and measure strings, you’ll move through C’s string world with a confident, steady pace.

One last tip for the road: when you’re working on projects that involve strings, keep a little checklist handy. Confirm that the string is terminated, check whether you’re using the length function that matches your platform’s expectations, and remember that safety and clarity often live in the same small decisions you make every day. The math is simple, but the impact can be big—so choose the simplest, most honest tool for the job, and let it do its quiet work in the background while you focus on the bigger picture.