Strings in C Are a Nightmare

Added: 2026-05-18

[00:00:00]Welcome back to a 33-year-old boomer teaches you stuff.

[00:00:04]Strings in C are kind of a nightmare, but they don't have to be.

[00:00:08]Let's have a little Let's have a little look at them. Let's create a little strings.c file.

[00:00:18]Okay.

[00:00:20]So, let's play around with some strings.

[00:00:25]You see the funny thing is that C doesn't actually support strings.

[00:00:29]Strings are kind of a high-level concept.

[00:00:32]A CPU doesn't know what strings are.

[00:00:35]So, in C, what a what a string actually is is a pointer to a an array of characters.

[00:00:46]So, the type would be character pointer.

[00:00:49]We'll pick a variable name Oh, I don't know. Something like this. And then, what string do we want? Let's say something random like this. I think that works pretty well.

[00:00:58]Now, let's let's examine our little string, shall we?

[00:01:02]So, we can do printf and we're going to specify a format.

[00:01:08]This is a format specifier.

[00:01:12]And I'll explain what it is in a second.

[00:01:15]And we'll do it We're doing a new line as well cuz I Once we print to the terminal, I want to do a new line.

[00:01:22]And we provided the variable femboy.

[00:01:25]So, now we can run it and boom, it prints the string.

[00:01:31]So, essentially, what's happening in memory right now is femboy points to an address in memory.

[00:01:40]And then, we're saying, "Hey, we want a string." So, in other words, it looks in memory and it prints the string that it finds there.

[00:01:50]So, why do we use these format specifiers here?

[00:01:53]Well, as far as the computer is concerned, there is no such thing as a string, there's no such thing as an integer, there's no such thing as anything other than zeros and ones.

[00:02:05]Let me show you.

[00:02:06]So, if if we did let's say we do something else. So, let's say we print a number.

[00:02:14]You do that with percent D.

[00:02:16]Let's say you know, like let's say we want to give it a binary number such as this one.

[00:02:23]Now, as far as the computer is concerned, when you ask it to print something, you're essentially just giving it some bytes.

[00:02:32]Is what you're doing. You're just give You're just giving it zeros and ones.

[00:02:36]When you ask to print something, the computer doesn't know what format you want that to be printed in because as far as the CPU is concerned, everything is zeros and ones.

[00:02:46]And so, by giving it a format specifier, you're saying, "I want you to print whatever I give you in this format."

[00:02:53]So, if we print this, you'll see that we get the number 69 because that this is the binary for 69.

[00:03:00]Um but of course, 69 itself can mean different things.

[00:03:06]What if you're you know, it could refer to a character. So, you can do C for character, and if you do this, bam, it's capital E.

[00:03:15]And if you want proof of that, we can literally just replace it with 69.

[00:03:20]Boom, capital E. So, that's why we're using these format specifiers. It's here's a bunch of binary interpreted in a certain way and printed for me.

[00:03:31]Now, as I mentioned earlier, uh I mentioned this thing called pointers.

[00:03:36]And if you've done C before, you may or may not know what they are.

[00:03:40]Um a pointer is essentially just an integer. So, if you have a variable that contains a pointer, it's it's just an address for somewhere in the memory where something else is.

[00:03:55]So, for example, if we want to see the address of the variable femboy, we do P for pointer.

[00:04:02]Let's also do a new line.

[00:04:04]And then we do the oops Oh, oopsie doopsie. Oh, oopsie doopsie.

[00:04:11]We do the address of femboy.

[00:04:15]So, if we print this, this is the add memory address in hexadecimal where this is stored. Now, bear in mind not not to get too autistic, but this isn't um this isn't the physical address. This is the virtual address because of course the kernel doesn't allow you access to the actual physical hardware. It acts as a as a a middleman between you and the hardware.

[00:04:43]Specifically because it would be a disaster if some some bratty femboy [snorts] doing C would get their their hands on on actual hardware.

[00:04:55]You could do all sorts of naughty things. And so you don't get direct access to memory. And so if I run it multiple times, uh if you look at the number, you'll notice that it's different every time.

[00:05:07]This you know, you can look here. So, 16AE26 16D362, whatever. Because every single time you run the program, the kernel puts you somewhere else in memory.

[00:05:19]Presumably there's a some sort of security measure because I assume that you could probably do some damage if you if you knew exactly where you would land in memory every time. Now, if you want some further proof of this, let's do let's declare another string variable.

[00:05:33]Let's call it a furry. [snorts] And um let's do this. I think that I think this is fine. I think I don't think we're going to get sued, right?

[00:05:40]I hope I hope >> [laughter] >> not.

[00:05:43]So, if we do this, as you can see, they're stored in different addresses.

[00:05:50]Femboy is stored here and furry is stored over here.

[00:05:56]Is this making any sense? Am I Am I making sense? Do Do tell me if I'm if I'm not making any sense. Now, let me show you something interesting.

[00:06:04]So, this asterisk thing means that it's a pointer.

[00:06:09]But, what happens if we put the asterisk right here?

[00:06:13]Well, let's find out.

[00:06:15]So, let's Let's not do pointer. Let's do a digit number.

[00:06:20]Huh.

[00:06:21]That's interesting. We get 68.

[00:06:24]Now, why is this?

[00:06:27]So, what we're doing is we're dereferencing the variable. So, what we're actually doing So, doing pointer to Femboy is literally just like doing this.

[00:06:40]That we're essentially pointing to the very first element in the Femboy array.

[00:06:48]Whether we do Femboy of zero or whether we do pointer to Femboy, it's exactly the same thing.

[00:06:54]Now, if you want proof of this, so we can do like a printf %c do n and then we just do 68.

[00:07:07]So, if you do this, then you get D, which is which which 68 is the ASCII character for D.

[00:07:16]Because here we're interpreting it as a number and here we're interpreting it as a character. If you want, we can literally interpret this as a character and as you can see, it's D, which is the first letter in the array.

[00:07:30]Now, you might ask yourself, what if we go past the string? So, this right here is 0 1 2 3 4 5.

[00:07:38]So, 0 1 2 3 4 5. So, if we do Femboy of five, we get I.

[00:07:44]So, what happens if we do femboy of six?

[00:07:48]Because if you try to do something like this in other languages, you might get You might get a little slap on the wrist. They might tell you, "Uh-uh-uh, you're not allowed to do this."

[00:07:59]But in in C, you can do this, and it gives you this.

[00:08:04]Now, you might ask, "Christian, what in the name of all all that is femboyish and good is this?"

[00:08:11]>> [sighs and gasps] >> Well, that is a null terminator.

[00:08:14]So, if you think about it, when you store stuff in memory, how is the computer supposed to know or how is the program supposed to know when a string ends?

[00:08:24]Well, what actually happens is there is a null terminator that is added at the end of these strings. So, this is actually this actually exists at the end of it. And this tells the computer, "Hey, this string ends right here."

[00:08:41]Now, if you want evidence of this, cuz I know you're very incredulous. I know you require loads of evidence for everything, which is good. It's fine.

[00:08:48]It's very good. It's very good thing to do.

[00:08:51]I'm going to show you. So, the um the character for the the character for ASCII zero is actually this.

[00:09:03]There you go.

[00:09:04]So, uh this is the character Many terminals use this to show control uh character.

[00:09:09]So, if you if you've ever done control C to stop a program from running, you would have seen this. And this represents null.

[00:09:17]Okay, so let's get back to this bit here, cuz I want to You see, I have a question. I'm very I'm a very curious individual.

[00:09:24]You see, I'm very curious. What happens if we do this?

[00:09:29]Because we've now gone past the null terminator.

[00:09:34]So, what happens if we print this on the screen? What what are we going to get?

[00:09:38]Cast your votes down below in the comments. Like and subscribe [laughter] Like and subscribe. Anyway, let's see.

[00:09:46]Huh.

[00:09:48]We get P. That's kind of weird. Why do Why are we getting P? What if we do eight? What happens then?

[00:09:54]Hmm, we get a lowercase R. Now, you may have noticed already that this is a bit of a coincidence because we have P and R right here.

[00:10:02]What What if we do nine?

[00:10:06]Okay. So, clearly what's happening is these two strings are being stored contiguously in memory.

[00:10:14]Because as you can see, if we just keep If we just keep incrementing femboy, we're obviously outside of femboy.

[00:10:22]What we're actually doing is we're referencing virtual memory. So, we can keep incrementing this and we keep seeing more and more of the furry variable. And I think with a like 15, probably the last uh primogen. So, then 16 is the null terminator for primogen.

[00:10:43]And then if we go past that, we're just going to get a bunch of like junk uh memory, essentially.

[00:10:51]Um which is essentially what happens after that.

[00:10:56]Okay. So, if we increase the index, then that's what happens. But, what if we print this as a string and we do this?

[00:11:05]What happens now?

[00:11:09]Because remember, what this variable does is it points to the very first character in the array of femboy.

[00:11:21]Now, what happens if we do femboy plus one?

[00:11:26]Let's check it out. And we're printing it as a string, remember.

[00:11:32]We start the string from the second position because if we have uh if we have um so we have this is this is essentially what we have in memory, right?

[00:11:44]So, if we if we're here, this is this is this is where femboy or femboy of zero leads to.

[00:11:53]So, if we increment that by one, what we're doing is this.

[00:11:58]So, now we start the string from here.

[00:12:03]That's what that does.

[00:12:05]Now, what if we do something else? What if we do this?

[00:12:10]What does this do?

[00:12:12]Let's Let's find out.

[00:12:15]Oh, sorry. My bad.

[00:12:16]Uh we don't we don't want to print a string. We want to print a character.

[00:12:22]Now, this is interesting. Why did we get E? How did this happen? How How in the world did we get uh an E?

[00:12:33]Well, let's think about this for a second.

[00:12:35]So, if we were to just print femboy like this, we get D, which is the very first element in here. When I mentioned earlier that there are no strings, as far as the CPU is concerned, the only thing that exists is binary. It's on and off.

[00:12:53]>> [snorts] >> Which means that strings are actually just binary, which means that strings are essentially just integers.

[00:13:02]And as you Sorry, not strings, but characters are integers, as we've as I've shown you earlier.

[00:13:08]And the beautiful thing about integers is that you can do mathematical operations with them.

[00:13:13]And so, what's happening when you do this is if we print that as a number is what's happening is you is you're doing 68 plus one, which is 69. Very nice.

[00:13:28]And of course, 69 is E.

[00:13:31]Because D + 1 is actually capital E.

[00:13:35]D + 2 is capital F.

[00:13:38]I + 1 is um is lowercase J.

[00:13:45]That's how it work. Isn't that the coolest thing ever?

[00:13:49]>> [laughter] >> Like Like let me show you.

[00:13:52]So if I if I do uh character I + 1 and we print it, that's 106.

[00:14:02]As [snorts] ASCII or as a character, that's lowercase J. Isn't that the coolest thing in the world?

[00:14:10]>> [laughter] >> Now, I don't know if you've ever asked yourself this question, but you might ask, what is the length of femboy?

[00:14:25]Well, there is a simple way that we can find out.

[00:14:30]So we can do something called strlen.

[00:14:33]So we can do printf. We're looking for a digit, so we're going to do strlen of femboy.

[00:14:39]Now, we also have to include another header file, which is strings.h.

[00:14:48]So if I do this, um Oh, it wants uh long unsigned.

[00:14:59]Femboy's long unsigned. Oh my god.

[00:15:01]There you go. Six. D I I N K I, that's six. And of course, if we do this for I I didn't even think about the long unsigned thing. That's That's really funny. Of course, Primogen is nine.

[00:15:15]Now, if you were like me, uh this is not sufficient.

[00:15:22]Because what I'm now wondering is okay, how how does strlen even work?

[00:15:28]Like how how does this thing even function?

[00:15:31]Well, as it turns out, we can actually write our very own very simple function to calculate the length of any [snorts] any string. So you're going to learn quite a bunch right now. Let's let's have a look.

[00:15:44]So first thing we're going to do is we're going to declare another function.

[00:15:48]We're going to declare a int type function. Let's call it length of.

[00:15:52]Uh we're going to feed it a string.

[00:15:57]Uh and int here just means that we're going to return a value that is an integer because of course we're returning its length.

[00:16:04]We're going to declare an iterator outside of uh the of of a loop that we're going to write because of course we want to retain the value of I after we exit the loop. If you don't know what I'm talking about, go check out the previous video where I talk about this.

[00:16:20]So we're going to do a for loop.

[00:16:21]We've already declared the iterator so we can ignore that part.

[00:16:25]So we're going to run this loop as long as string of I, so the current value, isn't a null terminator.

[00:16:38]Because if you think if you remember from earlier, every string ends in a null terminator.

[00:16:43]And so if you if you point it to a place in memory where a string starts, which is what the string variable is going to be, then the for loop is going to keep doing um uh sort of uh what's it called like index arithmetic or something like that where essentially it will it will iterate through each for each address in memory and it will check its contents until it hits a null terminator. And that is the end of the string.

[00:17:14]And we're going to, of course, increment.

[00:17:17]So all we have to do is i plus plus. That's it.

[00:17:22]So, i plus plus, this this is actually where the C plus plus joke comes from. Cuz get it? Cuz it's better than C.

[00:17:29]So, what this does, this is the equivalent of this. It's just a faster way of writing this.

[00:17:37]So, what happens here? So, let's let's say we feed it the femboy string.

[00:17:44]So, iterator is zero. We enter the for loop.

[00:17:49]So, we go string of zero, which is capital D.

[00:17:54]Is that a null terminator?

[00:17:57]Nope. Okay. Well, we go in here and we iterate one.

[00:18:01]Then we go whoop. We go back here.

[00:18:04]We look at I, which is the second element. Is it a null terminator? Nope.

[00:18:08]Whoop. We go here. We iterate. Whoop. Go back here.

[00:18:11]I n k i So, bear in mind that by the time we get to here, so this is zero, 1 2 3 4 5.

[00:18:22]We then go through here one more time and we're now looking at the sixth uh, element in the at the sixth index in this array, which is a null terminator.

[00:18:35]Is it a null terminator?

[00:18:37]It is. Whoop. We exit the for loop and now we hold the length of the string in the uh, iterator.

[00:18:46]So, all we do is we return I. So, 0 1, 1 2, 2 3, 3 4, 4 5, 5 6.

[00:18:56]And that's how we get the value of I.

[00:18:59]So, we return I. So, now all we have to do is we have to call uh, the function.

[00:19:05]So, all we need to do is we're going to print it as a number and we're going to do length of femboy.

[00:19:17]So, now if we run this, boom. We can also do length of furry, which is Huh?

[00:19:29]What is happening here?

[00:19:35]>> [laughter] >> Huh?

[00:19:37]Bro, what is happening?

[00:19:39]Am I losing my mind? mind? There must be something really obvious that I'm missing. So, Okay, let's do a bit of debugging. Let's see what's actually happening. So, when we we're going to also going to print the current meme.

[00:20:00]What?

[00:20:02]>> [laughter] >> What?

[00:20:12]I mean, I I appreciate the dick joke.

[00:20:14]That's funny, but what Oh my god.

[00:20:22]Ah.

[00:20:24]I'm >> [sighs and gasps] >> Ah. This is the problem here.

[00:20:31]Yeah.

[00:20:32]It's already being iterated here, silly.

[00:20:35]Oh my >> [laughter] >> god.

[00:20:39]Ah.

[00:20:41]Oh, no.

[00:20:44]Oh, I bet people were watching going lol. What a What a silly goose.

[00:20:50]What a silly goose. Is this going to be nine?

[00:20:54]It is nine. Oh.

[00:20:56]>> [laughter] >> See, you're watching some printf debugging in real time, my man. You're >> [laughter] >> You're welcome.

[00:21:09]Oh my god, man.

[00:21:12]>> [laughter] >> Oh, that was so funny.

[00:21:19]Oh my god, okay.

[00:21:21]Now, before we go, I I do also want to cuz I want to do a thumbnail where I also have like size of Uh that'll be fun to use. Let me show you how size of works.

[00:21:30]So, size of is a function that you can use to get the size of anything really. So, let's say you want to do this.

[00:21:41]Or actually, if we're going to do the might as well make it big. Let's go.

[00:21:45]So, uh this is Oh, sure I should print it.

[00:21:51]So, we're going to print the size of D, of course.

[00:21:55]Let's just do this.

[00:21:59]All right, it's not a I think it wants like long unsigned.

[00:22:06]Oh.

[00:22:07]Oh my god, what am I It's very hot outside, okay? That's the It does want long unsigned, lol. Cuz I'm not I'm on a Okay, yeah.

[00:22:16]So, that actually gave us four four bytes. That's because this is actually an integer. So, um which is Yeah, but if we if you want the the size of a character, it's actually one byte, right? So, um that's that's what this is. Am I Am I making any sense? Let's see, if we do value of femboy, that's eight um because uh we're on a 16-bit machine, so that's uh 64-bit or eight bytes.

[00:22:48]I think that I think that's good. Yeah, we'll just we'll just use that. Thank you very much for watching. I hope you enjoyed this. It was a bit all over the place. I think it was pretty funny.

[00:22:56]Hopefully, it was pretty informative.

[00:22:59]Um I don't know, if If want to check out my books, they're on GitHub.

[00:23:02]Got some cool stories right here. You can check You can check out Whisper, short story of Protectorate.

[00:23:07]And I'll see you in the next one.

[00:23:10]Bye-bye.