1:04 Introduction & Housekeeping

1:04 Hello, and welcome to today's episode of Rawkode live. I'm your host, Rawkode. Today, we're gonna be taking a look hands on introduction to c plus plus Now before we do that, there's just a little bit of housekeeping. First, if you're not subscribed to the YouTube channel, I would encourage you to do so now. Subscribe and click the bell, and you will get alerts for all future episodes of Rawkode Live as we explore and learn this vast cloud native landscape together. If you're not watching live and wanna come join us in the chat, there is a

1:33 Discord server available at Rawkode.chat. Come in there and say hello. We talk about all things cloud native, Kubernetes, rock music, and a whole bunch of other things in between. So we look forward to welcoming you. Now to guide us on our journey into c plus plus today, I am joined by a c plus plus developer advocate at Microsoft, Cy Brandt. Hi, Cy. How are you? Hey. Good. Thanks very much for having me. How are you doing? Very well. Thank you. And it's a pleasure to have you here. I've seen a few of your talks over there the last

1:43 Guest Introduction: Sai Brandt

2:00 year. All very very interesting and exciting and very low level at times. But I think those are those primitives are really good way to try to understand really complex topics as well. So I'm very, very excited to have you here today. Can you do us a favor? And just for anyone who is not familiar, hasn't seen our talks, doesn't follow you on Twitter, give us the introduction to Sai. Yeah. So my name is Cy Brand. I work as Microsoft c plus plus developer advocate, where I spend most of my time on Twitter just, like, making nonsense.

2:36 My background is in, compilers and, debuggers, tool chains for for graphics cards. I spent about five years writing, like, GPU compilers and debuggers, which is where I got, like, fascinated by really low level stuff. And, yeah, that's where my kind of love for developer tools and things like that came from. So then I've been at Microsoft for for a couple of years now and, still, like, giving talks about c plus plus, getting involved in the ISO standardization. Like, I just got a feature hopefully getting into c plus plus 23, which just got approved a couple of days

3:14 ago. So I'm very excited about that. Awesome. Okay. Well, we got people saying hello in the chat. Hello, everyone, and welcome to today's session. Everyone. You also like to explain low level concepts for viewer cats, and you have your own YouTube channel. I will include a link to that in the description, but you wanna tell us a little bit more about that if you want? Yeah. Sure. That was basically I I come from, like, a very traditional background of computing. Like, I did a CS degree. I have been programming for since I was, like, 10 or something.

3:50 So I I, like, come from, like, the traditional background. But then when I went into the industry and started working with people who come from different backgrounds and saw how they saw things and explained things differently, And it was sometimes a lot more digestible, a lot more understandable the way that they're approaching things. I wanted to try and, like, join those two things together, like, bring all of the the knowledge and interest I had from, like, low level concepts, from my experience with compilers, and from from my degree and things like that, and take different approaches to to trying to

4:25 explain these, like explaining with household objects and my cats and whatever I happen to to have around. So that's Yeah. The odd child toy, I think, has popped up there and again as well. Yeah. Yeah. Yeah. Yeah. I explained hash tables with my my kid and some teddies, and the the hash function is how cute the teddies are. Awesome. Which is a terrible hash function. It makes it fun and entertaining. We'll learn on these concepts. You know, I think you'll do a lot of credit for producing this content and material. It's a it's a joy

4:55 to watch. Okay. Now you've got your biggest challenge of all which is to introduce me to c plus plus a language that I haven't played with in in many many years. But I wanna I'm gonna give a shout out to one of my former colleagues, Stuart, who works at Influx Data. He kept telling me for years now, go and look back at c plus plus because it's not the c plus plus that I'll remember. Like, he had many good things to say about the evolution of the language. I think you just mentioned that version c plus plus 23 is now a thing.

4:57 Host's C++ Background & Modern C++

5:25 So like, I'm curious and excited to see some of these new constructs in the language and and how they're gonna hopefully improve it to me. I think my image of c plus plus back, you know, and let me clarify. This has come back at least fifteen years, think. So to me, it was the difficult language. Having only ever done Perl and c at the time, I think now, hopefully, with my experience, it's gonna be a lot more familiar and easier. But he's always had said really good things about modern versions of it, so I'm excited

5:53 to learn that today. Okay. Let's jump over to my screen share. We are using Exorcism today. Are you familiar with Exorcism at all? No. I had, like, a brief look, but, yeah, I've never used it before. Yeah. It's a a really cool project that has, like, language tracks. In fact, let me just quickly do the thirty second pitch but It has language tracks. A lot of tracks. Yeah. It says here showing 50 and I'm assuming there's maybe Yeah. I love the x 64 assembly I kinda wanna do that one. I haven't done that much x 64 in a while. That

6:01 Introduction to Exorcism Learning Platform

6:32 would be cool. Yeah. It's it's it's a nice website for picking up on your language. It kinda guides you through a bunch of different problems that start with like really easy things like hello world and simple challenges which normally involve working out leap years, etcetera, but then they go down to more difficult things. And that kind of guide through the language would be cool enough on its own. But you'll see here it also says there's mentors. And all that means is that when you submit your solutions to problems is that the mentors generally review them and give you feedback on

7:05 how you can write more idiomatic code in that language. So it's a really Yeah. Interactive way of learning as well. Yeah. I think that's really, like, valuable thing as well because there's there's getting the right answer, and then there's having a solution which is, like, actually edematic and maintainable and performant, and those can look very different. So, yeah, having that mentorship on top sounds like a really good thing. Awesome. Well, I think we should start with hello world. I think it would be rude not to. That's good. I have a local directory here where I've already downloaded the hello world example.

7:29 Starting the Hello World Exercise

7:41 I have my Versus code open, and I've got the basic files here that we need to get started. So let's open the README. Probably a good place to start. So our objectives here, and I like that it always kind of lays out what we wanna do. The other nice thing about for people that aren't familiar with it is they provide tests for all of the examples. So your goal is actually to make the test pass, which means you get introduced to testing in the language as well as writing code, which I think is really important.

8:12 Examining the Hello World Test (Catch2 Framework)

8:12 If we pop open our test, I have never seen a test in c plus plus before, so this is exciting. Okay. So this is using the catch two testing framework, which is probably the most popular testing framework for for open source projects right now, I would say. It was developed by Phil Nash, and it's yeah. It lets you have these, like, quite nice requires statements where you just say, I require that hello world hello is equal to to hello world rather than, like, some other testing frameworks where you'd have to say, like, require equals or require true or things like that.

8:52 Okay. So this makes sense to you then as a test case. Good. Good. That's good. And is this is this the test framework you would use as well in in your This is what I use for my my open source projects as well. Yeah. So that that test case in in case is this is a test case, and it's called test hello. In fact, one of the cool things about catch is that you don't need to use, like, c plus plus, identifiers for your test case names. You could call that test hello as as two words if you wanted. You could

9:25 use special characters in there. You can do whatever you want. And then you can also it also takes a a tag so you can, like, up your tests into different tags and and, like, run large subsets of tests. So you want to, like, run only the, like, command line driver test or you want to only test, like, some part of your application, then you can do that with catch. So it's it's quite nice. Okay. Well, I mean, there's one thing that's jumping out to me right now that is that is confusing me is that at first, I

9:52 thought these were function calls. But I noticed that the test case here has then got braces after it, which makes me think it's maybe not a function call. Right. Exactly. So these are macros. Macros in c plus plus is essentially the same as c macros, if you're familiar with them. So they're the and the the idiom is to use all caps when you when you have a macro because macros can do weird things, which normal, like, c plus plus functions cannot do. So bringing attention to the fact that, hey. This is a macro. Pay attention. Something

10:02 Understanding C++ Macros

10:28 weird might be going on is why we use case. It's like how how Rust uses the the exclamation mark or the bang after the macro name just to draw attention to, like, hey. There may be dragons. Yes. Okay. That makes a lot of sense then. Well, these are macros making writing tests easier. Yeah. Exactly. I've got one more question. This is not really related to the test case here, but is there now, like, a de facto way in c plus plus to pull in libraries? Like, is this pulling in a cache library through a package manager or something? Or

10:50 C++ Dependency Management Approaches

11:03 That's a very good question. So, basically, we are so c plus plus was originally standardized in 1998, like, a very, very, very long time ago when, like, dependency management was not a thing which, you know, all languages just had, and they had great solutions for handling your dependencies and saying what your dependencies were and what versions they were and things like that. But C plus plus is having to to evolve. So there is no standard dependency management tool, nor de facto or DigiArray. There are a few solutions. The two major ones are Conan and vcpackage.

11:46 Vcpackage is is the the Microsoft one, so it's the one that I'm most familiar with. Okay. So this, I can't tell what this is using just by okay. It looks like it's literally just using the the header only version of CAPS. So, yeah, when when you when you cloned this directory, it just has a copy of the CAPS testing framework in it. So it's not using any dependency management stuff. Okay. Well, that that's good to know. That makes a lot of sense. But I'm keen now that we jump into our hello world. Like, we've got the test. I understand

12:21 Hello World Implementation: Includes & Namespaces

12:26 this. Require is like an assertion and c plus or at least in the catch framework. We're calling our hello function, and we're expecting to get the string hello world back. Yep. If we look at our code okay. This looks a little bit different from what I remember. So the good thing is I remember they include pragma. I do not remember namespaces or using keywords. Cool. Well, I can walk through, I guess, from from top to bottom kinda makes sense. The very first thing at the top there that hash include hello world, this is how you bring

12:30 Hello, world: Headers, Namespaces, and Functions

13:04 other functions or names or or types from other files into your your current file, essentially. So c plus plus, just like c, has, things split up into implementation files like this one, which is a a dot cpp file, and header files, which are dot h or sometimes dot h p p as well. Different people use different things. But, basically, the the header files are a description of the types and functions which, you can call and use, and then the implementation files are, you know, the actual implementation of those things, what the the actual code does rather

13:45 than how you can use it. So the this hash include just brings everything in that helloworld.h to to make it available in this file, and it literally does do textual inclusion. So when when you do a hash include, it, like, literally takes the entire contents of that header file and dumps them into into this file. There are in c plus plus 20, which is the the most recent version of c plus plus has a feature called modules, which, is a more like, if you're familiar with modules from from other languages, it'll be a little bit more

14:24 more reasonable. It doesn't just dump in entire text files. It, like, actually looks at the the symbols and names available and exports them in in sensible manners. But this is this is using the the old style, and I I think the version of Clang you're using, which is the the compiler, doesn't support modules yet. So so we can't use modules. But, anyway, modules will make this better. Anyway and then the the using namespace std. So std or std is the the namespace where everything in the standard library lives. So std string is the standard library string

14:58 implementation. So when you say using namespace std, that says, okay. If I type some, unqualified name just like we do later on where we say string and we don't say std string, we don't say some other namespace string, if I just say string, then I want you to look in the the STD namespace. It's basically a way of stopping you having to type the namespace. I will say that it's probably not that idiomatic to using namespace std. Some people do do it, but, generally, I like to make it obvious when I'm using something from the the standard library

15:41 Sorry. I guess it's to my own code. Idiomatic to maybe just do this and not pull in std? Yeah. That's that's what I would prefer to do, but it's you can do either. The the main thing is to not write, like, using namespaces in the header file because then that will get copied into everyone else's files, and now you're, like, looking for standard library names when you maybe didn't want to. You know? In fact, I just noticed this comment here, which is actually telling us that we could Absolutely. Yeah. Do that as well. Okay. So that's when we say when we say

16:14 names on line five now, when we say namespace hello world, this is defining our own namespace. So everything in the standard library lives in the std namespace. Now we are saying, okay. Everything inside these braces is inside the hello world namespace. So this is just a way of, like, qualifying names so that, you know, if I have a function called hello and I include some other library which has a hello function that they don't conflict with each other. Is that mandatory? Nope. So you could just completely get rid of namespace hello world and the, the closing brace at the end, and you

16:54 would just have a an unqualified hello function, which lives in the global namespace. Oh, okay. So you can do that, but you shouldn't because then if someone else does that, then everything goes horribly wrong. Plus our test does seem to fully qualify it here. So Yeah. I guess I should And the test could just like we had earlier, the test could say using namespace hello world, and that would be a very, very reasonable thing to do in your in your test suite. If you're gonna be using all the names from your own, library anyway, then,

17:27 then you could just write a names using declaration like that. Okay. Awesome. That's great context. I'm gonna make a wild assumption right now that just changing this to hello world is probably gonna pass my test. Yep. Can we walk through the process then of confirming that? And then we do have a couple of questions on the chat that I'll get to in minute just a minute, Daniel and Kai. So Sure. I've modified this. I think my test is good. I'm assuming I jump to the command line, go into the directory, I'm presented with a CMIC list dot text, which I'm not

18:00 Building with CMake

18:05 entirely sure what that is. I'm sure I could read the read me, but do you wanna just give us the TLDR on building this thing? Sure. So just like with with dependency management, there is no standard build system for c plus plus. However, CMake is essentially the de facto build system nowadays. It's what most c plus plus projects use for building. So it's essentially a it's its own language. So if you if you, like, look at the CMakelists.TXT, that's a description of how to build your project, and it's written in the CMake language. So we have things like,

18:46 yeah, this add executable command that is saying how to build the the executable for our project. And you can see further down where it says set target properties. That's saying, oh, we want to use c plus plus 14 as our as our version of the standard, and we don't want any extensions, like, we have compiler extensions from Clang or GCC or whatever compiler you're using. So Is CXX the way to that always mean c plus plus rather than CPP? Yes. Alright. CXX is the way that the it's the the the term that that CMake uses, which is

19:29 what, like, Auto Tools used as well, if you ever used Auto Tools back in the dark ages. It's quite a lot to build Hello World. Yeah. This is not, like, all like, if you wanted to have an absolutely minimal thing, all it would literally need is a minimum CMake version and and project specifier and an add executable. Like, this whole thing could be three lines if Alright. They wanted it to be, but they're probably doing other things. You know, like, they've got stuff stuff to run the tests later on and and whatnot. So Yeah. I I guess this

20:10 is just one of those things that as you start to work with more c plus plus and get more acquainted with the tooling and stuff, it all becomes a lot familiar, I guess, like any other language. So So if we want to build this, then the the usual thing you would do is you'd make a directory called build, and then change dir into there and then run CMakespace. Dot. Yep. So CMake is a it's not actually a build system. CMake is a meta build system, which sounds kinda weird. But, basically, it's a because there's so many

20:47 different ways to build code in, you know, in Windows or in Linux or Mac or BSD or whatever you're using, CMake generates a build system for you. So if you use, like, Visual Studio, then CMake could generate a a Visual Studio solution. Here, you can see it's generated a Makefile. Nowadays, most a lot of people use Ninja, which is another build system. So, yeah, this is the the Makefile which is generated for you. So now if you run Make, then it will build your project. I know make. That's that's something. Yeah. Alright. And you can also run c make

21:31 dash dash build dot, which will will do your build step regardless of what generator you're targeting. We had a capital letter mismatch. I broke my code already. Alright. So we could change that back. Well, we're changing the test instead of the code. What did I? Yeah. Is that not no. Of course not. Right. Okay. That's what I do if my code doesn't work. I just change the test until it pass. There we go. Yay. A testy hello world. Heard you that oh, no. That did run run the test as well. Yeah. Because the the CMake lists,

21:44 Running Hello World Test & Fixing Error

22:14 yeah, had a a target which ran the tests for you. So nice. Yeah. So our default target here runs all. Yeah. Generally, you don't wanna look at the make file that generated, but you can if you want and it's just it's it's not pretty. I know. We let's not do that. I'm more interested in the language itself, and we'll touch on bits of the tooling as as needed. But so far, so good. It's all starting to come together. It's probably a good picture in my head. Hopefully, also for the audience too. But I'm gonna So that's

22:48 how you'd use CMake list from the the command line. Also, Visual Studio Code has CMake extension as well, which makes it that you can just build from from from within Visual Studio Code. Oh, cool. Yeah. I I don't need to think that right now. Let me read out these questions for you. I'll let you tackle them in whatever order you want, and then I'll get the next exercise ready. So Kai starts off with a, hopefully, a nice simple one, but Kai is curious of how do namespaces differ from classes. Yeah. So Sorry. Oh, yeah. You go for

23:07 Q&A: Namespaces vs Classes, C++ Compilers

23:26 that, and then we'll come back to you, Go for this one. So a namespace is just a way to split functions and classes into digestible units in a way which they don't the names do not conflict with each other. You cannot have, like, an object which represents a namespace. Like, you can't create, an instance of our hello world namespace. You cannot pass them around or do anything like that. It's just essentially a prefix to, any names which are inside those blocks. So whereas classes, you can, create an instance of one. You can pass one around. You can give it

24:12 data members. You can give it functions which you can call on instances of that class. Namespaces are just named prefixes, essentially. I guess if we were to correlate that to Go, which I think Kai has a a better familiarity with, then namespaces would be like packages and classes would be like structs, which also happen to have methods on them as well. I think Sure. I don't really know go, but that's interesting. Alright. Daniel seems to be jumping straight into the deep end, I'm afraid, with his first question. But Mhmm. He's saying a lot of folks in the

24:45 cloud native community are just a Go Mhmm. Which, unless you're using GCC Go, pretty much has one compiler. Can you maybe talk about some of the trade offs of the various c plus plus compilers? Absolutely. So the main compilers which are available for c plus plus are Clang, which is the compiler which OSX uses and is also available on Linux and now Windows. GCC, which is the the good new c plus plus compiler. So it's the the one which is kind of the default on most Linux systems. MSVC, which is the the Microsoft c plus plus compiler as that's

25:34 the the team that I'm on at Microsoft. And there's also ICC, which is the Intel c plus plus compiler, but it's not quite as common. So as far as trade offs and differences between them go, they're all good at different things, And which you target is sometimes related to which platforms you will be targeting, Windows, Linux. Quite a lot of projects will target multiple compilers. So, like, if you're if you're building for Windows and Linux, then maybe you're you're gonna target MSVC for Windows and target GCC or Clang for for Linux. If you're writing a generic library, then you

26:21 probably wanna make sure that your code will compile on all of those platforms. If you are targeting just one specific compiler, then you can do, like, more aggressive optimizations. Or even if you're targeting multiple compilers, you can write code which will, you know, do certain things on with some compilers and use certain things on other ones. So there's there's a lot of different things you can do. Alright. Awesome. I didn't realize there were so many compilers. Yeah. Okay. Hopefully that answers your question, Dan. Now we have cloned our second exorcism tutorial challenge. I'm not sure what we call

27:01 Starting the Isogram Exercise

27:06 them. But it wants us to determine if a word or a phrase is an isogram. An isogram is a word or a phrase without any repeating letter, however spaces and hyphens are allowed to appear multiple times. I did not know what an isogram was until three seconds ago. So there we go. Yeah. So is it wait. Is it adjacent characters or is it just okay. Now it's Yeah. Think it's Yeah. If the the character appears twice anywhere in the string, then it's not an isogram. Okay. Oh, yes. Okay. So, yeah, isograms is not an isogram because the s is on

27:47 it twice. Okay. So, yeah, we can't have any any letter twice in our word or phrase. Yep. So we already have I'm just gonna start with the test cases here. We've got empty string. That makes sense to start with. And we're expecting to get a true value back because spaces don't count. I find it curious that they actually define and expect it as a billion, and I'm not sure why it's got braces for output and then have the assertion. Is is that idiomatic? No. No? I am kind of confused why they did this as well.

27:55 Examining the Isogram Test & Requirements

28:22 So and and as far as that that line 12 goes, that so maybe we can talk a little bit about about variable declarations in general. Yeah. So the the variable declarations here on line ten and twelve, they both begin with const bool. So bool is the boolean type. Const says that this is an immutable variable. So try changing this will not compile. If you do some shenanigans in order to get the compiler to accept you changing it, then it's undefined behavior, and your program may blow up. So right at the start, we have the type

28:26 C++ Variable Declarations & Initialization Syntax

29:03 of the variable, then we have the name of the variable, which is actual in case of line 10. Then we have, the equal sign and an initializer. So actual will be initialized to the value of, returned by the function isogram is isogram. Now on line 12, this uses slightly different syntax for, declaring a variable. So this is valid. It's not really idiomatic. Like, I would just use equals true there if I was going to be. Yeah. Yeah. Either having require true equals actual or just having expected equals true. Yeah. Exactly. I I see very, very little reason to

29:51 use braced initialization there. Braced initialization, you mostly use if you're initializing, like, a a container, like a an array or a vector, and you want to give it a set of initial values. You know, like, you you want an an array of zero one two three, then you would use braces and write zero one two three in those braces. There's no real reason to use it in this case, I don't think. Okay. Well, I'm just gonna remove that one because I I I don't understand it. In fact, I don't even Sounds good to me. This one. Like, that to me seems perfectly

30:22 acceptable. Mhmm. Okay. So let's see what code they have given us to work with. Matter. Not a lot. Alright. So it's expecting an is isogram function which takes a string. We have a namespace already. So I'm assuming I've got maybe I should disable Copilot. Is that is that cheating? Alright. So we're we're gonna be returning a boolean. Right? Because we're okay. So now now we can maybe talk about strings a little bit as well. So there is a few different string types in in c plus plus. If you go back to the test Yep. So

31:06 C++ String Types (string literal, std::string, std::string_view)

31:07 anything enclosed in double quotes, like that, is a string literal. So that's any string which is embedded into your program. The type of a string literal is a constant character array. So this string literal will be a a constant array of one character because they are, they're null terminated. There's always a a null character at the end. But string literals are well, arrays in c style arrays in c plus plus are a little bit weird because they can change to pointers. We generally try to shy away from them. So in c plus plus, the main types we use for

31:53 strings are std::string, which is a string which owns its own data. It has buffer stored inside. It can be modified. It can grow. And the other type is std string view, which is actually, if this is using std string view is a c plus plus 17 thing, so it might not even allow us to use string view. But string view is essentially a a view into some existing string. So we don't own the the memory. We're pointing at some memory which is stored elsewhere, and that could be a string literal or it could be, like, an existing

32:34 std string stored somewhere else that we're just referencing into. If you're familiar with Rust, then it's like a std string is the capital s string, and string view is like a ref stir. Okay. Yeah. That does make sense. The the rush string stuff, I understand. I didn't know it was so similar to the c plus plus one, so that works really well. Now Yeah. Is it string view? Is that what you were seeing there? Like so? Yeah. So that is what would ideally be used here. I think wait. I mean, we we can try it,

33:10 and if it doesn't compile yeah. It's already saying that's oh, wait. We we'd have to include the the header for it. So, yeah, up there, we do hash include. And then so there's there's two different syntaxes for hash include. There's hash include yes. Exactly. That's what we want. There's hash include double quotes, which looks for the things in our own project, and there's hash include angle brackets, which looks for system include headers. So we would hash include string underscore view just the same as string view, but without the std. Yeah. Exactly. Oh, it's happy. Okay. It's happy. We'll see

33:52 if we'll see if it builds. Okay. So what we wanna do is isogram. Yeah. So our our first test case is just empty string. So I'm assuming if we have an empty string, we're just gonna return true. Yeah. So we could say if stir dot empty. Oh, empty. Okay. Yep. Exactly. Like so? Would that work? Yep. All good. Mhmm. And I guess we need a default case. That's good to me. I just add don't I don't see any red squiggles, so that usually keeps me happy at the start. Alright. So I would make a build directory.

34:37 I would run c make dot dot. Mhmm. And then go. Yep. Okay. So I got something wrong. November is isogram and namespace. Isogram. Did we, go into the header file? So, yeah, we've got isogram dot c p p. We also got isogram dot h, so we need to declare our, our function here. So Would you just copy and paste the sling? Yes. And end it with a semicolon. So this is saying that somewhere, nebulously, there exists a function called isogram, colon colon, isisogram, and this is the the header file which people will include into their program in order to

34:56 Header Files vs Implementation Files

35:28 know that there's something we can call call this. And then when we compile the program, then the linker is gonna, like, work out where this function is actually defined. So is it fair to make this like, any function defined inside of a namespace is essentially private until we add it to the header file, and then we're making it publicly available at that point in time? Alright. Okay. Yes. You can think of it that way. It gets a little bit there's more details, but, yeah, that that's a mental model which checks out for the the basic cases. Yeah.

36:00 So if we run make now, then I'm getting under or so I didn't use Okay. So in the in the header file, you need to also include string view. Alright. Okay. Yeah. Because the header file needs to know because it's taking a string view as a parameter, it needs to know, like, what the the size of that is and how to pass one around and things like that. Well, because this includes dot h, do we still need the string view here? No. You could get rid of that. Okay. Alright. I was compiling a bit longer this

36:37 time. That's probably good. K. They're still past. Okay. Awesome. Nice. Let's see what our next test case is. Now it looks like it's using is this macros? Would you call them pragmas? I'm not sure. Macros. Yeah. Macros. I'm assuming I could just remove that, and that would bring in this test case. Or Yeah. I think there's probably something defined in the CMake which defines that, but, yeah, you can just get rid of it as well, I'd say. I'll just move it down. I'm assuming that brings in one test that I I don't know why it's still grayed out. Oh, there

37:14 we go. Okay. So now it really likes that brace syntax, I'm gonna say. Yeah. Now we wanna call isogram on isogram. Okay. So now we're gonna actually have to do our first bit of actual code. So I think we're gonna need to be able to loop over each of our characters and just store them in an array. So maybe we could talk about first how do we define an array to store scene characters. Sure. So are we how are we gonna be doing this? Are we are we gonna be only assuming that our string is ASCII

37:52 and then counting if there's more than one Yeah. I think each, or are we gonna use a hash map? Or there's a few different ways we could do it. Yeah. So let's do a hash map and then if the key exists, we'll just immediately return false. Otherwise, we'll continue to loop over and store them. And, yes, we'll stick to ASCII. There's already been a joke about UTFE based on another series I do called clustered. I'll talk about that later. No UTFE. Okay. Yes. The UTFE story for c plus plus is is a mess. Yeah. Let's let's take the ask you then.

38:08 Isogram Implementation: Data Structures (std::unordered_set) & Templates

38:33 So first of all Yeah. Like, how do I define a hash map then to be able to store the scene characters? Yep. So the the default hash map in c plus plus for reasons is called std unordered underscore map. Like so? Yeah. That's it. So unordered map is, we'd have to include the the header for unordered map as well, which is, it's just called unordered map. Okay. So we want to do an include on our yep. There we go. I feel like these ones should be above the string ones. Is that something you would do? Or

39:13 Yeah. Okay. I'm sure if it's like a whatever. It doesn't matter. But Yeah. So unordered map is a class template. So templates in c plus plus are the the basic way to do generics. So if you're familiar with, like, traits from Rust or, like, Swift protocols or, Java generics or whatever anyone else calls them, it's it's kind of a a similar thing. So you can't just create an unordered map. You have to create an unordered map with some key type and some value type. So in this case, our unordered map is going to be a map from,

39:55 characters, which are char, c h a r, to, I guess, just Yeah. If we're if we're doing a char to to build like, if if we're just checking if we've seen it before, then we actually actually don't need an unordered map. We could do it with an unordered set. Yeah. Because that's just checking whether it exists yet or not. Yep. Exactly the same. So we would just have it on our the template syntax? Yep. That's the template syntax. So, yeah, so for for our declaration, we would need to say, stood unorderedset will be the first thing in our declaration

40:42 because that's the type. So we'd say std unorderedset char scene semicolon. Yep. And that will construct an empty unorderedset, and that will be our our scene object. Okay. Cool. So the first thing popping into my head now is when we call dot empty, which I didn't know was possible on the string view, I'm assuming we can get the characters or an iterator or something we can loop over as well through a function? Yep. So we could do that by by calling functions, but c plus plus has the the idea of a range, which is basically

41:00 Isogram Implementation: Range-Based For Loops

41:31 the beginning of some range and the end of a range, and those two things are called iterators. So anything which supplies a begin and end function is a range in c plus plus, and we can loop over things which are ranges a lot easier than anything else. So we can use what's called a range based for loop, which is like a for each loop or for in or whatever you might know from from other languages. And so the syntax for that is just for and then parenthesis. And then we need to say what the type of the thing we are looping over

42:10 is. In this case, it will be, characters, so just char. We need to give it a name, so, I guess, just c. Yeah. Letter. And then colon. And then what we're looping over, which is str. Yep. So this reads for character c in string, do whatever is, is within these braces. Okay. So I'm assuming we can do scene hat? No. Contains? .Contains, I believe, is I don't remember what the the interface for We have find. Maybe we should just find. So find will will return an iterator. There is contains, but it says that's in c plus plus 20.

43:03 Isogram Implementation: Checking for Duplicates

43:11 We can use dot count. So if you yeah. Would that not return the size? Yes. But current dot current will Oh, current. Sorry. No? No. No. It's dot current. So we'd see scene dot current and give it c as the as the argument. Yeah. I've got two dots in there. Yep. Yeah. So this will because it's an unordered set, then current is gonna either return zero or it's gonna return one. So Right. Okay. Gotcha. If in c plus plus yeah. That that will that will be fine. Yeah. So that that will check to ensure that

44:05 c is not in scene. I'm just gonna make this up now, but I'm assuming we could do this. I think this is gonna do an early return, although I could be wrong. And I'm assuming here, could we continue? Yeah. So you could do that. I generally try to not use continue in loops because it makes them very difficult to to read. I would instead use put an else clause after the the if and and do a return false in there. Yeah. Okay. Well, it looks like it's complaining about my for loop. Let's fix that first then.

44:53 Did I get something? Looks fine. Maybe try and compile it, see what the compiler says. Okay. That compiled just the test. Yeah. Think okay. Just my Versus code then. Yeah. Okay. So we are ranging over our string and pulling out each character. Mhmm. If the count for that character is zero, we're going to insert it. If it's not zero, that means we've seen it before. It is no longer an isogram, and we return false, which now means if we get down to here, we're actually return true. An isogram. Look at that. There we go. Nice.

45:40 Handling Isogram Edge Cases (Spaces, Hyphens, Case)

45:40 Then we can, I guess, uncomment the other test because there was another one? I don't think we may have a a bunch. But Yes. I think just get get rid of that if I think, and there'll be matching one right at the end. Oh, there's a lot of tests. Yeah. Get rid of that end of let's just see if they all pass. Alright. Failed. Alright. No. We don't handle there were some exceptions here. So it said hyphens and spaces are allowed. So I guess if we just quickly add Yeah. A condition to not look to skip

46:22 over them. Yep. So if c equals this So character so things enclosed in double quotes are are string literals. Things enclosed in single quotes are characters. Yep. So we want we want that. Yep. We could say if if c equals hyphen or c equals space, you could do it in the the same I was just saying in the in the same thing you had. Oh, yeah. We don't want to insert this, do we? Okay. No. Yeah. Just have another yeah. Perfect. Yeah. And then you've got a a trailing Yep. Yep. So in c plus plus, double bar

47:12 means you can also just write or. That works as well. Nice. I quite like it. A lot of people don't because No. I think it reads well. To the double bar. I think it does as well. Yeah. Okay. Should I continue in here or should I just do nothing? Yeah. You can write a continue in there. But because we've got the change conditional, so we should be okay just doing that, I think. Yeah. Maybe. We'll see. The test will tell us. Oh, okay. So two edge cases. It's not really given me mixed case. So we have to lower case it.

47:58 Using std::tolower

47:59 And the last one is also just the mixed case thing. So. Yeah. So we could use std to lower or std to upper, just a normal case. Part of the range, or would you create a new variable? Yeah. You probably wanna you could just you do c equals to lower c. That's all one word, to lower. It's a can't remember which header it's in. Split to lower is in the c type header. Okay. How would you work that out? C c type. I'm sorry. Say that again, please? It's c c type, two c's at the start. Yeah.

48:57 It's a that's an old c thing. Yeah. You would generally work that out just by going to CPP reference, which is, I'd say, the best online c plus plus reference website and just typing in the function if you want, and that will tell you what what header is. Yeah. Exactly. That's it. Okay. Oh, I forgot my semicolon. I have format it, which is just an indicator that my code is maybe alright. And all of our tests Yay. Okay. There's quite a lot to kind of unpack here. So I like the unordered set. You said we also had maps. So

49:37 Reviewing Isogram Solution & Concepts Discussed

49:42 there's all of these built in data structures for handling, I guess, most of the common use cases. We got the range for Mhmm. Which was cool. Like, does c plus plus have functional primitives for doing this? Like, you know, the ability to maybe map, filter, etcetera? Right. So prior to c plus plus 20, there there are these things called algorithms, which are in the algorithms header. And those are kind of what you're looking for. We have things like transform, which is basically a map, lets you run some function over all of the elements in some range. We've got, like,

50:22 remove f. We've got, like, couple two or three dozen algorithms in that header. Yeah. The problem with those is that they don't compose very nicely. You have to essentially have, like, intermediate data structures. So, like, if you wanted to do a transform followed by something else, then you would, like, transform your string into some other string and then operate on that. C plus plus 20 has ranges which compose. So you could, like, build up a pipeline of operations and say, like, okay. We've got my string. I wanna transform it. I then I want to filter it. Then I wanna

51:03 drop the first three, then I wanna do this, then I wanna do that. And those would all only they would happen lazily. So only when you ask for an element do all of those operations actually occur. But the the version of the compiler you're using does not implement those yet. Okay. Awesome. Alright. I'll throw one more question out because this just something I've been curious about. Like, my very old knowledge of working with c and c plus plus required a lot of mallocs and the allocation. We haven't had to do any memory management yet. Now is that just because our types

51:23 Q&A: C++ Ecosystem, Documentation, Community, Conferences

51:39 are mostly primitives or just because c plus plus handles some of this for me? So, basically, if you're so in in c plus plus like, see, we have malloc. C plus plus has new. If you're writing c plus plus and you use new to allocate memory in 2021, you're probably doing something wrong. You gen generally, we try to avoid allocating a dynamic allocation as much as we can. If we do have to allocate dynamically, we try to manage that allocation with some standard container, like, unorderedset here. Unorderedset is doing allocation internally and not exposing that to us.

52:22 We could, if we wanted to, supply our own allocator and do a bunch of ridiculous stuff. But for, like, 99.99% of our use cases, then, this is just gonna handle all the memory management for us. If we do have to do our own memory management now, we would not use new and delete, because as much as people say, oh, simply remember to to call delete, like, that that doesn't work. So in c plus plus 11, they introduced smart pointers, which are essentially help you do memory management. So unique pointer is the main one you would use. You

53:04 would create a unique pointer, and when that unique pointer goes out of scope, it calls delete automatically, so you don't need to remember to do it. Awesome. Thank you. Okay. Let's tackle a couple of questions from the chat, and then we'll try and squeeze in one more of the extra system ones. But let's see. Oh, Mozz. Hey, Mozz. Oh, there's an interesting question. Hi, everyone. I saw after goal, there would be no need for c or c plus plus. Oh, come on, Mozz. No. We're we're actually seeing a good uptake of c plus plus in the

53:36 cloud native community. I think primarily driven by Envoy. I'm not sure if you're familiar with the project, but it's a a network proxy. And the reason I think Envoy and other projects are now starting to use c plus plus is for a lot of performance reasons over at Go. So no, Mozz. I don't think Go means we don't need it. I think there are definitely a lot of use cases out there. I I don't know if you want to add anything else to that or just leave it at it. Yeah. Definitely. Like, I think that what c plus plus gives

54:05 you is full control over the layout of your data. And and and you're aware, like, cache performance is, like, one of the most important, areas of of optimizing your program, then having the ability to do that is super important. So, like, thinking about how your data is laid out such that it makes the most of the cache, such that you don't have, like, multiple threads contending over that can just give you incredible performance boost. I remember once, like, this was for for a GPU, but adding a single no op into a loop, improved performance by 10 times because it made much better

54:52 use of the instruction cache, things like that, which you just cannot do in in so many other languages that don't give you that much low level, control over how you layer your data and how it's it's used and cleaned up. Yeah. That's a lot of projects that even are using Sego a lot of the time to bring in some of this other stuff too. So definitely very popular. Okay. Ben Woman is asking, does c plus plus have an official or unofficial documentation or reference site? Yeah. Basically, c plus CPP reference is the the de facto standard is the one which

55:00 Idiotmatic C++ and C++ Conferences

55:29 most people will go to. Alright. Carlos suggesting that Infinidash is written in c plus plus I've heard rumors otherwise, but we'll see. Russell is asking, are there any sites to find out a duomatic c plus plus? Good question. I think there's there's one called CPP patterns or did it change its name? I'm just looking it up. Yeah. CBP patterns. Second one. Yeah. Yep. This is a decent one. It tells you what version of the language it allows, things like that. Doesn't look like it's been updated for C plus plus 20. But, yeah, things like this,

56:21 going to Stack Overflow, like the usual kind of places you would look. There's also the the hash include c plus plus Discord, which is a Discord community for c plus plus focused on making, like, a welcoming, inclusive environment. That's always a great place to go and say, like, hey. I've got this this code. Is there a better way to do this? There's always people there willing to to help out. Why don't we flip that question a little bit then? You know, you're you're quite involved in this c plus plus community. So, like, what are the the bigger conferences that

56:54 maybe people can check out some of the talks that are coming out? Sure. Like, the biggest one is CPP Con. I just so happen to have this, like, right here. Yeah. CPP Con is usually in September. It's gonna be October this year. It usually has, like, six, seven, eight tracks, runs for about a week. It's a it's a pretty big conference. I think I gave four talks there last year. Oh, wow. One year, I gave I gave five talks and, like, helped run a panel and things like that. I would not recommend doing that. It

57:29 was exhausting. Sounds like a stressful week. Yeah. Yeah. That's c b p con. C plus plus now is probably the best one for, like, expert level content. And then the smaller ones like c plus plus on c, CPPP, which is the c plus plus Paris, the Madrid c plus plus Spain one. There's a bunch of of smaller conferences as well. ACCU as well has a bunch of really great c plus plus content. Right. Definitely no shortage then of c plus plus content. Yeah. Yeah. Yeah. And the the conferences are only growing as well. Like, there's

58:07 new obviously, not right now, but previously, there were, like, new ones popping up pretty much every year. Awesome. Okay. Let's use the next kind of fifteen minutes to maybe just tackle one more of these. We won't go through all the test cases, but maybe if we can pick something that shows off a little bit more of the language. Is there any features you would you think would be nice to show and we can try and find an exercise that uses them? Talking about type inference would be good, but I feel like we can build that in pretty much

58:38 anywhere. Let's see. What about Nothing involving randomness, so that I don't have to explain randomness in c plus plus. It says pattern recognition here. Is that pattern matching? For it. There is not pattern matching, but at least we can we can talk about that and and what might be coming in the language. Yeah. Okay. Well, let's see what we can kinda make of it. Even if we go a little bit off script, that's alright. So let me clone this one. Jump over here. So what is it asking for? Once does to generate the lyrics of the

59:00 Type Inference (auto) and References

59:17 song, I know an old lady who swallowed a fly. Not a song I'm familiar with, but it's a cumulative song of unknown origin. Yeah. I have no idea what this is asking. Yeah. So I think the the song is usually like you you have a line and then in the next verse, you repeat that line and then add a line. And then in the first after that, you repeat the first two and then another one. So it's it's like building up the song. Okay. Let's see if they give us any code to start with, and then we'll make a

59:56 decision. Yeah. So we got our test case here. We're expecting a string. Alright. Okay. So we're calling the verse function and we're giving it how many verses we want out of our new lines added to it, I guess. Yep. Let's see what we have. Oh, we get nothing. So it's a maybe we could just make it up. Like, it doesn't matter if the test pass, but maybe we can talk about pattern recognition and maybe we can talk about type inference as we go. Are you comfortable kinda just making this up? Yeah. Yeah. Yeah. We can just make something up.

1:00:35 Modern C++ Concept: Type Inference (`auto`)

1:00:38 So the yeah. Type inference, why don't we just make a function which doesn't do any return anything? Just we've got something to play with. Yeah. Void means I'm a function which which doesn't return anything. Void is like a special type in c plus plus It's not quite a unit type if you're familiar with the concept of unit type, but it's the the closest that c plus plus has, basically. So so type inference in c plus plus, like, previously, we've been declaring variables by writing their type and then a name and then an initializer. You can also write auto

1:01:20 instead of a type. So if we write auto here, and then name, yeah, equals yep. So this will based on the type of the initializer, will deduce a type for that variable. So this uses the same rules as as templates do, which is kind of nice in in the way that the it's like that this came in c plus plus 11, kind of reused a lot of the the existing rules in the language. But, basically, when when you're using more complex c plus plus, you end up with really, really, really long types. You know, it might be like a

1:02:09 vector of the iterator types for a vector of integers, and you don't wanna write that type yourself. So we now allow you to write auto in there, and it will work out the type from the initializer. It's not like Rust in the it will, like, look how you use the the variable downwards in the function. You know, like in in Rust, you can say, I have a this is a vec, and later on, you, like, assign an int into it, then it, like, looks forward and says, oh, later on, you use an int, so this must be a a vector of

1:02:46 of integers. And c plus plus is has to be based on the type of the initializer, but it just it cleans up so much code. And you can use this in in range space for loops as well. Like, earlier, we wrote char c, which was the the type which we were iterating over. But you could just write auto there, it will work out for you. So you're saying we could have done auto c name Exactly. Yep. And then whatever the okay. Yep. It seems to be complaining about my supposed to type as missing and assumed.

1:03:27 Yeah. But when I hover over, is that just my editor again, maybe? Yeah. I think it's just your editor. The the compiler would be happy with that. Okay. Oh, maybe something else we can talk about is references. Yeah. So if we well, we write two functions. Yeah. And make that one take a string. Yep. And then write another function called, yeah, whatever. Another one. Some other. Yeah. Okay. And make that one take a Std string ref, so ampersand. Oh, ampersand. On the variable name or before the standard string? It's yeah. After standard string, it can be

1:03:36 Modern C++ Concept: References (Pass by Value vs Reference)

1:04:23 it doesn't matter which side of the space you put it on. Oh, okay. Yep. So these are two different functions. Another takes the string by value, which means that the inside another hello is some completely new string, which is completely separate from any of the context outside the function. So if we pass, say, our our name from inside our hello function, the the David thing into another, then nothing can ever happen to that name. Yeah. It will be the the copy inside of another is is something completely separate. The version of some other, however, has the ampersand

1:05:08 after, after the string. This will actually not compile. I'll get to that in a second. But, when we put an ampersand after a type, that means that it's a a reference to that type. It's not, a copy. It's like an alias for something else. So in c plus plus references are mutable by default. So if you pass some string into some other, then some other could, for example, change the first character of of the name, or it could append some additional data onto it. This is how you, you can, like, mutate things while passing them

1:05:49 around functions. And then if you wanted to make it a reference but you cannot change it, then you would do const std string ref, in in the declaration of some other. Okay. Mind if I ask a few questions? Yeah. Go ahead. Okay. So if I hover over David here, it's kind of the type of inference is maybe suggesting that this is a const char six, but it doesn't seem to mind me passing that as a standard string. Is there some type juggling happening here? Yep. So c plus plus has implicit conversions, which is basically, in some cases,

1:06:13 Modern C++ Concept: Implicit Conversions

1:06:28 you can pass, you can initialize, some object with an object of a different type. And as long as there is some conversion function which can convert between the two implicitly, then it will just work, and it will do some magic to to convert it. And there's a few different ways that you can specify those conversions. So converting a, string literal to a std::string is one of those cases where there is an implicit conversion function, which will, take the contents of the the string literal and copy them internally into a std::string, and that will potentially allocate some memory dynamically,

1:07:14 which will then be freed when the std string is is destroyed. Right. Okay. So if I were to implement my own type in c plus plus and I wanted to be able to convert it to a string that would just be implementing a function on Exactly. Right. Okay. Yep. And implicit conversions are a little bit contentious because, you know, in some places like this, they're super useful. Like, of course, you wanna be able to convert a a string literal into a string. Like, that's something which is is really useful to do. In some other places, like, they seem like they

1:07:49 might be ergonomic. They might make things easier, but you can run into to issues where you get, like, inputs and conversions where you maybe didn't want them, and it can cause some some additional errors which are really, really difficult to see because, like like you said, you you see that you can pass this, thing of a different type to another function, and it just works. Some some magic happens, but it's not obvious that there's a conversion happening here. You you have to know that the that these two types are different and if there's some way to convert between them

1:08:21 to know that there's a conversion happening, it's not clear from looking at the code. Awesome. Alright. I'll throw one more. We don't need the code up anymore, I don't think, unless we wanna jump back. But I'll throw one more question at you just because, again, I have curiosity. Like, we've been now writing c plus plus for a little over an hour, and we haven't typed a single class. Is that normal in modern c plus plus that you use maybe just functions within namespaces, or does it just, again, come down to the domain that we're actually building something out?

1:08:40 Modern C++ Concept: Classes, Abstractions, Performance

1:08:54 Yeah. It definitely comes down to the domain. A lot of the power of c plus plus comes from the ability to create your own to work at the level of your domain without having to pay, runtime cost in order to do that. So what that means is creating your own types, which express, you know, your your business logic or whatever you wanna call it, being able to write templates which abstract, common behaviors of your types, being able to create, code which can sometimes read, like, the operations you want to do, but will, like, compile to a bunch more code under the

1:09:42 hood. But you don't have to, like, handle that, but it will happen in a way which is which still gives you the performance that you need. So the the the common term that's used is zero overhead abstractions Yeah. Which is another, like, slightly contentious term in the community. But, basically, it means that being able to write code a high level of abstraction without paying undue performance cost. Awesome. Well, thank you very much for joining me today. It's been really good fun learning c plus plus. I'm really glad that we can, you know, understand or dug into the tooling

1:10:10 Conclusion & Additional Learning Resources

1:10:19 a little bit. I had no idea about CMake. Really cool to see the way the tests were structured and then just a few nice implementation details of just to acquaint myself with the language. But I I feel like I understand things a lot better now, and you've been into quite a fair amount of detail on some of those features features as well. So I just wanna say thank you very much because it was really good fun. Yeah. Thanks for having me. Alright. Well, you have a wonderful day. Thank you again. Thank you to our audience for watching.

1:10:47 Do you have any last words before I I say goodbye? No. I think if you're interested in, like, learning modern c plus plus, I would have a look at, Kate Gregory's Pluralsight courses. They are are really good and teach, like, modern c plus plus, for for beginners in a way, which I really like. There's a bunch of really good books, like, true c plus plus is now updated for c plus plus 17, I think. I can't remember how much c plus plus 20 is in there. But, also, if you're, like you've done c plus plus before and you are interested in,

1:11:29 like, how c plus plus 20 will change things, I'm really interested in, like, making good resources for this because we're we're still in the the education phase of this. Like, c plus plus 20 is kind of new, and it comes with a lot of really new, like, big features which can really change the way that we write c plus plus. Like, we we talked about ranges and being able to compose these in in a way which you might be familiar with from from other languages, like chaining iterators in Rust or whatever. So, yeah, keep your eye out for resources

1:11:58 on that, and let me know if there's anything that you're particularly interested in because, yeah, I wanna, like, make good stuff on this. Alright. Well, I will make sure I include a link to your YouTube channel and to that Pluralsight course and all of those other super plus reference websites that we mentioned at the session. They'll all be in the description. And thank you again. Have a great day, Cy. Yeah. Thanks. See you. Bye.