Mix C++, C, and Assembly into One Program - Hybrid Program Full Build Tutorial - video Dailymotion

Neural Lantern

Want to write a single program that uses C++ for high-level logic, C for portability, and assembly for speed? This video shows exactly how to do it.  We build a complete hybrid program from scratch:  - driver.cpp - contains main(), prints intro, calls assembly  - c.c - simple printf() function  - cpp.cpp - C++ function (with extern "C" to disable name mangling)  - hello.asm - assembly module that prints messages, calls C and C++ functions  You?ll see: - Why hybrid programs matter - How source files ? object files ? final executable - The role of the driver and why main() lives once - Name mangling in C++ and how extern "C" fixes interop - Global / extern in assembly to expose and call functions - A clean Makefile that compiles each module separately - Live build and execution with output explained line-by-line  By the end you?ll know how to call across languages safely, pass basic args via registers, and structure projects for fast incremental builds.  No prior assembly required - just basic C/C++ familiarity. Code is copy-paste ready.  Timestamps in comments. Source files linked below.  Like & subscribe for more systems programming!  What is a Hybrid Program 00:00:00 Why Use Hybrid Programs 00:00:21 Program Modules Overview 00:01:10 Compilation to Object Files 00:02:23 Makefile Introduction 00:04:26 Driver Module Setup 00:06:43 Name Mangling Explained 00:07:18 C++ Module with extern C 00:07:43 Driver Main Function 00:10:12 C Module Implementation 00:11:52 Assembly Module Setup 00:12:41 Assembly Data Section 00:13:03 Assembly Text Section 00:14:18 Global and External Functions 00:14:35 Assembly System Calls 00:16:20 Calling C from Assembly 00:18:58 Calling C++ from Assembly 00:20:32 Program Execution Flow 00:21:05 Running the Program 00:23:59 Passing Arguments Between Modules 00:26:23 Hybrid Program Summary 00:29:11  Thanks for watching!  Find us on other social media here: - https://www.NeuralLantern.com/social  Please help support us!  - Subscribing + Sharing on Social Media - Leaving a comment or suggestion - Subscribing to our Blog - Watching the main "pinned" video of this channel for offers and extras

Transcript

00:00Hello there. Let's talk about hybrid programs.

00:10What's a hybrid program? A hybrid program is basically a program where you have multiple

00:15modules, many written in different languages, all compiled into one executable program. Why

00:21would you want to make a hybrid program? Well, you know, maybe you have C++ as one of the modules

00:26that you're creating and C++ is a high level language. So it makes it easier to write big,

00:31robust programs with GUIs and like big design, big fancy design patterns and things. But maybe

00:38at some point you want to interface with the C program. So it might make sense to, you know,

00:42kind of jump into some C code. Maybe also you want to write a little module in assembly because maybe

00:48one part of your code needs to be really, really fast and efficient in some way. And assembly gives

00:53you a little bit more control over how the code compiles down to machine code. Assembly is just,

00:59you know, a level up from machine code. So let's see, I'm just going to write a quick program to

01:05demonstrate that you can do this and you can have these modules call each other. First off,

01:12I should probably draw a little bit about what I'm even talking about with multiple modules. So

01:17I'm going to do my little annotator here. And yeah, there we go.

01:21Basically imagine that you have a C++ module and we'll call it the driver.

01:27And I'll say like driver.cpp. Okay. I think I'm drawing this backwards.

01:33I'm going to draw this down here. Driver.cpp.

01:39Excuse my penmanship. I don't have a smoother setup on this thing. So we have driver.cpp. That's one

01:44source code. Maybe you have like another module, another source code module.

01:50I'm going to call it c.c, which is just some C code. The driver, usually the way I like to refer

01:56to it. And one of my favorite, you know, assembly books refers to it is the driver is where the main

02:03function is so that it's sort of like the entry point of your program.

02:06But then maybe we'll have another module that has some other kind of CPP code in there. I'm just going

02:10to call this file cpp.cpp. And maybe we have another module that's written in assembly. I'm

02:16going to call this hello.asm. Okay. So just several source code files. We will compile them each to an

02:25object file. Sometimes I think with new programmers, they think that you just compile a source code

02:31directly to the executable. We're not going to do that in this case. We're going to get a little bit

02:35fancier. Doing it this way, by the way, will increase your compiling efficiency when you

02:39start getting used to make files. I don't know if you're already using those, but it's a good idea.

02:45So we'll write a script to compile or make file to compile or some kind of a build system to compile.

02:50We'll compile the CPP driver to just a file called driver.o. O for object file.

02:58So O for object file depends on driver.cpp. We'll have another file called c.o. So the

03:05object file c.o depends on c.c and so forth. So I'm just going to go cpp.o, circle it,

03:13and then down here we'll do hello.o. Notice how all of these modules, regardless of the language they

03:19were written in, compile down to an object file. That's really what it is. The higher level languages

03:26are just an illusion for us humans. So then at the very top, we want our actual executable file.

03:32We'll call it main because that's kind of a standard thing sometimes. So it's like our main,

03:39we'll have a file named main that we can execute. And of course, inside it somewhere is going to be

03:44the main function. Spoiler, it's going to be inside the driver. Remember the main function, if you're using

03:50GCC libraries has to appear in exactly one place, one module in your program, it should appear one

03:56time and one time alone, not zero or more than one. So the main executable depends on the driver object

04:04file, the C object file, and the C++ object file and the assembly hello object file. Looks complicated

04:12at first until you stare at it a while and then you just realize, oh, every source code is going to compile

04:16to its own object file. And then after we have all the object files, we're going to have our executable

04:21just sort of linked together at the final linking stage. So with that in mind, I'm just going to

04:27copy paste a make file that I already wrote. It's like my pre-solution because this is not a make file

04:33video. And I just want you to know just real fast what it looks like. All I'm doing is I'm going to make

04:38some variables for my C++ compiler flags and my C compiler flags and my YASM assembler flag.

04:46I'm really not doing anything fancy. I'm just sort of setting up some variables so I don't have to type.

04:51The newer Ubuntu stuffs need a no executable stack flag and a no pi flag. So here we're just like

04:59making variables for linking. My executable's name is going to be main over here. I personally like

05:05to make make files that default to a cute help menu. I know most people just default to building.

05:11But, you know, for educational purposes, I think this is a little more fun, a little easier.

05:16So this way later I can just type make menu or make build or make run or make clean or whatever I want

05:21to do. And I'm going to make a target called run, which is what we're going to be using. And then

05:28a target called build, which just only builds everything. The run target obviously depends on build

05:33so that the program actually gets built before we try to run it. And, and if you don't know make

05:39files at this point, it's okay. This is not a make file video. I'm going to make some make file videos

05:43in the future.

05:44Then my binary, the main program is just going to depend on all these object files. Notice how it

05:51depends on the driver, the hello, the C++ and the C object files. So really at the linking stage,

06:00we're just going to use G++ to just sort of link all the object files together.

06:05Then we have a little section to compile each source code file. So in order to make driver.o,

06:10I'm going to compile, I'm going to depend on the driver.cpp. And then when it comes to actually

06:16compiling, compiling it, I'm just going to type the commands to compile it here.

06:19Don't worry about these crazy variables. I'm going to make more videos in the future. And then each

06:23module gets compiled in its own way. Then I just have a little target at the bottom called clean,

06:27because I like to be able to just clean my build area of object files, because I don't know about you,

06:33but I like a clean build area. I'm a clean build area guy. I don't like a dirty build area. So that was the

06:38make file. Again, this is not a make file video. So don't worry too much about it right now. The

06:43next thing we should do is make a driver. Again, I'm going to copy paste from my solution here because

06:48the driver should be easy. This is really, this video is mostly going to be for people who have

06:53never done assembly before. So I'm just going to assume, you know, a little bit about C++ and C

06:59already. So I'm going to say touch, let's see driver.cpp so that I can get the driver file in there.

07:06And I'm going to go nano driver, probably put it down in the first place. Then I'm just going to

07:10paste my solution. Oops, you can tell I copy pasted this from my IDE because I have the

07:15extra tabs in there, which I love. One thing to keep in mind is that I guess like one of the full

07:22first rules that I want to tell you for hybrid programs is that assembly doesn't understand

07:26something called name mangling. So what is name mangling? Name mangling is basically when you have a,

07:33uh, oh, this is not going to get called. So this is maybe not a great idea or to show you name

07:39mangling. Let me, let me start on one of the other ones real fast too. Let's do the C++ module. Okay.

07:45So I'm going to go nano cpp.cpp. I know it's a silly name. I know it. So, uh, cpp.cpp, this is just a

07:53simple C++ program, which is meant to be called by, uh, the assembly module just to show you that we can.

08:00And so we just have a little function here void, you know, the CPP function. So it's just a function

08:04that doesn't really return anything inside of it. I'm just going to print. Hello. This is the C++

08:08function. No problem. Notice at the top, this is the first important thing that you should understand

08:14in C++. We have overloads, right? You can have the same function name, but with different argument

08:20lists. And so, uh, that gets resolved under the hood by the name actually kind of changing based on what

08:27the argument signature is, what the prototype signature is. So that's, that's great and all,

08:33but in, uh, assembly, at least at this level, there's no way to really differentiate between

08:38overloads. In assembly, we'll just call a name of some function. But if we try to call a name,

08:45let's say of just the CPP function, if we say call the CPP function in assembly,

08:51it's not going to work because the actual function has not been compiled

08:54to have that name. It's been compiled to have the CPP function and a bunch of extra symbols

09:00indicating what the argument list is. This is great for C++ programs, but it's poor. It's bad

09:08for other modules to be able to call the C++ function because they won't really know what

09:12the actual name is after the mangling has been done. So what you want to do is make a little block

09:18called extern C, just like this, you say extern and then C in quotes, and then do a scope with braces.

09:25And inside of that, just put the prototypes of any function that you want to be available

09:31to other modules. So for example, we want the CPP function to be available to assembly modules

09:37and C modules, not just other C++ modules. So I'm just going to put the prototype of it right there.

09:42You can put as many prototypes as you want. I think they should come from the same source file.

09:47So basically every different source file where you want something to be available elsewhere,

09:50you would, you would put an extern C block for its prototype. This disables name mangling,

09:56which means the compiled name of the CPP function will actually be the CPP function. So it's pretty

10:02good. This will make it available to assembly. So now that I've kind of explained that I can maybe

10:07close this and go back to what I was doing before. So this is the main driver program. We don't need

10:13to engage in, we don't need to disable name mangling for the main function because no one is going to

10:21call main except the GCC libraries or like the OS. But when the C++ module calls other modules,

10:31it needs to be able to call the right name. And remember in C++, there's name mangling enabled by

10:36default. So if I tell it, let's say on this line right here, or you can do Alt N to get line numbers on

10:41nano, let's say line 16, we want to call on the hello module will C++ by default will assume

10:48that hello has name mangling applied to it, which means it will actually try to call some name that

10:54is totally different based on the prototype signature, the incoming arguments and things

10:58like that. But so we want to disable that because we want it to just call the actual name because hello

11:04is going to be a function that we make inside of assembly. So it's not going to be name mangled.

11:09So that's why up here on line seven, we enter its signature. Oh, actually,

11:14this is from a different version of something that I was doing. I'm not going to return anything

11:17from hello. We'll do name D mangling with our extern C block, just void hello. And now when we call

11:25hello, it's actually going to call a function called hello without any other mangling. Same thing for the

11:31C S E A. Oh, that was from a different version I wrote. We're not going to be calling C in this

11:37module. Don't worry, we're going to keep it simple. So pretty much we're going to print hello. And then

11:41we're going to print, then we're going to call the hello. And then we're going to say goodbye. And then

11:45that's going to be the end of the program. So let me close out of that and just double check what I have

11:51written right now. So we've got CPP and okay, we need to do C nano C dot C. Okay, so let me get my

12:00solution real fast here. It's a simple program. Literally, it's just a C program that prints

12:04something. Remember in C++, we've got the IO stream, but we don't have that in C. So I'm just

12:09going to use print F. Oh, by the way, this is a C function high. So done with that. Pretty easy.

12:16Um, shoot, you know what? I need to start learning how to do clear and LSA so I can just go up, up, up.

12:24So C++, uh, C and the driver

12:31and the make file, which is huge. I just realized that. And now I guess we can start

12:35writing our, um, hello function. Okay.

12:41So maybe I want to write this in, uh, the genie program. So I'm going to

12:46well, maybe I'll first, I'll say touch and I'll say hello dot assembly. And then now that it's

12:51there, I can try to open it up. Let's see. Hello dot assembly. Okay. So now let's write an assembly

12:58program. I'm not going to spend too much time talking about this, but I'll say like data section

13:03here and we'll say section dot data. And then we'll say, um, system calls. This is not a system calls

13:10video. I'm just going to do this very quickly without explaining system. Right is going to be

13:16code, uh, one, I guess. And then we're going to do a file descriptors one for STD out. Whoops. STD out.

13:25It's going to be equal to one. This is not a file descriptors video.

13:29I'll put FDs, I guess. And then, uh, we'll make some C strings, C strings, you know, just, uh,

13:41character arrays. Basically I'll say, well, you know what, I don't want to type this all out

13:45because this is not a lesson on variables. I'm just going to copy paste my existing solution here.

13:52And, you know, long story short, I'm going to try to make this a pretty program that prints hello

13:56and goodbye and things. And so we just have like some variables that sort of just, you know,

14:02old strings and hold the strings length. Um,

14:07and we're going to do one that calls a new line and so forth. Actually,

14:12that'll be a different video, but I'll leave it in there for now.

14:16So now let's make the text section. Remember the text section in Yasm is just for the actual

14:21code of your program. So I'm going to go section.txt. And then we need to, um,

14:30set up some external symbols. So right now, at least, uh, for the purposes of this source code,

14:36this source code is inside of the hello module. So you can imagine we're inside of hello.o.

14:41All the o's get linked together in the executable, but, uh, between themselves,

14:46there's kind of a little bit of a, like a border situation happening. There's like some

14:50separation. So not all symbols that I put into hello are going to be available to the other

14:57modules, even if they're part of the same executable. It's kind of convenient because

15:01you would like sometimes to be able to write tons and tons of functions that are only available

15:06inside of your assembly module, and they might not be available to other modules. And therefore,

15:10you don't want to pollute the, the namespace, I guess, of the, uh, global namespace of the executable.

15:16So by default, if I make a function called hello, how you make a function, just, you know,

15:21quick recap here. This is not a functions video. You just make a symbol with the name of the function

15:26you want, and then you just put a ret after it. And then you hope that whoever got you there

15:31is going to use the call instruction. But anyway, for now, we're just going to say,

15:35this is our hello function. Okay. I cannot call the hello function now from another module.

15:43I have to make it visible to the other modules with a special keyword called global. So I'll say global.

15:49Hello. And now after we compile and link our program, the hello function will be available to

15:56the other modules, but not anything else that I type without marking it as global. So let's go ahead and do

16:06let's do a welcome message. And this is not a system call, uh, video. Maybe I should just copy

16:12paste this. So just looking at it, this is a welcome message here. So I'm going to say first,

16:19I'm just going to quickly, you know, breeze through what we're doing in case you're interested,

16:23but you don't have to care too much about this right now. Uh, we're going to tell RAX what system

16:29call we want to make the code for that is, uh, what I put up in system, right, which is just code

16:33one means let's write to a file. We'll give it the file handle. Uh, that's going to be the variable

16:40we made called FD STD out, which means we're going to be giving it the file handle of one,

16:44which means we're telling the system a call to print to standard output because file handle one

16:50is always standard output. And then we just give it the, uh, a pointer to the first character of the

16:56message string that we made and then tell it how long that message is. Then we do system call.

17:01This should actually, um, this, this should actually print a string. Okay. So then, uh, let's see down

17:10here. I'm going to make a function called CRLF cause I'm lazy and I don't like constantly adding extra

17:17stuff to the string so that there will be like a new line line feed situation. So I usually like to

17:22make a little function somewhere called CRLF carriage return line feed is what it stands for.

17:28And it's the same thing. It's just like load up the system call registers so that it knows I want

17:33to print the string, which is just a line feed, uh, carriage return line feed, and then actually call

17:38system call and then return to the caller. So this is just a really, really simple function.

17:43And if you look back up here, let's see, CRLF, I guess I am going to be doing it.

17:49It's just a string with, uh, the slash R slash N or the carriage return line feed, uh, characters in

17:55ASCII. Those are 13 comma 10. So I can put that there instead of a, a literal quoted string.

18:02Okay. So we got that. And then that means after the welcome message, I can just like call CRLF

18:07in order to have, uh, the cursor jump down to the next level after that string is notice how I don't

18:13have any line feeds after my strings. That's kind of why I like to do CRLF. And it lets me just call

18:19CRLF a bunch of times if I want to just like space things out temporarily. Okay.

18:26So we've got the hello function and now we're going to print another message here. I'll just

18:31explain this real fast. So I'm going to print a message about calling a C program.

18:39So same thing. We're just going to tell the system call, uh, service that we want to print a string.

18:44And it's going to be our string here that says, you know, we're about to print this, uh, we're

18:47about to, what do we say? We're about to call the C function. And then later we're going to call the C

18:52plus plus function. So we're just going to print a message announcing and do CRLF. So that's really

18:57nothing new at all. And then down here, we actually call the C function, which is not going to be in this

19:03module. It's going to be in the C module, the other source code. So that means somewhere in

19:08this program, we need to let our assembly module know that the, uh, the C function is available

19:15because it kind of goes both ways in assembly. I have to mark a function as global if I want other

19:21modules to be able to call that function. Uh, but I also have to mark a function as external

19:27if I want to be able to call some other modules function. So we have to go back up to the top.

19:32I mean, somewhere in the tech section I think would be fine, but for me, I just like to put

19:36it at the top at the top. So I'll say externals and then I'll go extern keyword and then just

19:43name the function that I intend to call this way. When the linker is trying to link all the objects

19:48together, it doesn't get upset because you tried to call a C function, which is not in the current

19:52module. It'll understand that, uh, it's going to happen, you know, like it's going to call other

19:58modules for that. It usually gets upset right away. And then while we're at it, let's do extern, uh,

20:05the CPP function because that's going to come from the C++ module. So now we have both of our external

20:12functions set up. We've marked our global, uh, hello function so other modules can call us.

20:17And then let's see, oh, what did I do wrong? I put the C message in the wrong spot.

20:22I was inside of the CRLF function. So I'm just going to copy paste that back up here.

20:28Okay. So then, uh, we'll do the same thing for the C++ message or for the C++ stuff. I will first

20:38print a C++ message with these lines up here. That's just like a regular system call. And then

20:42I'll do a CRLF. So nothing new, just printing something. And then I will actually call the C++

20:48function called the CPP function. Then I'll say goodbye with another block of text.

20:55Again, not super important or complicated. So I'm just going to paste it, uh, just another string.

21:00And then when we're done, I'll just say, you know, return we're done. So that means if you notice how

21:06we don't have like an, uh, any symbols in here called underscore start, that means this is not

21:11a pure assembly, um, program. And we don't even have a symbol inside of here that is called main.

21:17So that means this hello ASM module is not going to be the entry point of our program. It's just going

21:22to expose a function called hello, which does some stuff. Uh, the entry point of our program

21:27is really, uh, let's see, where is that? Okay. I think I already closed it for some reason.

21:33It's the driver program, which we talked about. So remember the driver program, it's got a main here.

21:37So that means this is going to be what, uh, the GCC libraries or the operating system calls,

21:43however you want to think of it. Uh, so this is the entry point of our program. It'll just print

21:46something quickly. Then it'll call the hello function, which means execution will jump in

21:51to the hello module. So at this point we know how to call an assembly module from a C++ module.

21:57And, and also it would be really easy to apply this logic to have a C module call on an assembly module.

22:05And in fact, you can use this logic to have every type of module call on any other. I mean, just

22:12if you have a C++ function, either being defined in the current module or being referenced in another module,

22:18just make sure that you have an extern C block. And then if you're inside of a C++ module and you're

22:24going to call a non name mingled module like C or assembly, then just do this block

22:30here. No problem. What else can I really tell you? The C module, we looked at that, the C++,

22:36we looked at that pretty easy. Hello module. I mean, I guess we're kind of done already. So what we

22:42should see now is a little intro here. Hello, my name is whatever. And then when we jump into the

22:47hello module, we should see a little welcome message about being in the assembly module.

22:52And then we should see a message about calling the C function. And then the C function should print.

22:57Let me open that up for you. Let's see. The C function should print

23:00just Oh, by the way, this is the C function. And then when it returns at the very end,

23:10remember, even in a void function, there is a return statement implicit at the end of scope.

23:15So when it returns, it'll come back down here. And then the C++ message will get printed. And then

23:21the C++ function will get called, which is going to end up being

23:24just it just prints, you know, another message, this is the C++ function. Then when it returns

23:33implicitly at the end of the function, then we get down to here where we just basically say goodbye,

23:38and then return to the caller. The caller in this case, is going to be the driver program,

23:43because this whole time we were just inside the hello module or inside the hello function that we

23:48called. So then the driver will say goodbye, and then it will return control to the GCC libraries or the

23:54operating system ending the program. Let's see if that works. Okay, clear. And so you know,

24:00the way I wreck my make files, I'd like to do a little menu, I type make and it's like, Oh, the menu,

24:05make menu. Hmm, make build, just in case just to see what's up. Okay, clear.

24:13And then I'll do make one more time. So I really just want to say, you know, let's do let's do clear

24:18and make run because that's really what we're after. Again, run will implicitly call build.

24:25So do that. And it seems to have succeeded. It wasn't actually very exciting. Let me do a make

24:29clean. So you can see it compile real fast. We run it, it's compiling, that was still kind of fast.

24:36So up here is basically the make file, all these lines, they're just calling your normal compiler

24:43and assembler tools, and linker tools. And then here's the driver, like we said, it prints the hello

24:49message, you know, my name is whatever. I love that name. I have a strange name generator that

24:54I found online. That's not my name. You can call me that if you want to. And then we have the message

25:01that we're going to call the hello module. So now we've called into the hello function inside

25:05of the assembly module. Assembly module prints. Hello, you know, I'm inside of here now.

25:10And then the assembly module says, now we're going to call the C function. And then the C function

25:15actually executes. And it is now printing with its print F function call that it did, you know,

25:20by the way, this is a C function. Hi. And then it returns to the caller. Maybe I could have added

25:26another print statement if I felt like I wanted to spend more time. But it returns to the caller,

25:31which is the hello function, then we get to the next part of the hello function where it's like

25:34now calling the C function as a print statement, then it actually does call the C function,

25:39the C function prints itself out. Hello, this is the C function. And then the

25:48assembly module says goodbye, it says it's finished.

25:54And then it returns to the caller. So finally, at the end of this print statement, the there's like

26:00that little return statement at the bottom of the hello module that returns to the caller,

26:03which was the driver.cpp program. So then the driver prints, the driver is now back in control,

26:09you can see that message behind the terminal here, the driver is now back in control,

26:13then it says goodbye, then it returns zero to the operating system, and the whole program is done.

26:20So it's important to understand that if you want to pass arguments, right now, I'm just going to say,

26:26you know, I'm going to make another video that is more robust in the future about passing arguments

26:30back and forth between these, it's important to understand for now that you can pass arguments

26:36between all these different module functions if you want, like if I wanted to give the

26:42if I wanted to give the hello function

26:47an incoming argument, let's say like an integer or a character value or a pointer or something like that,

26:53I could just load up appropriate registers. Remember, we have argument registers in assembly,

26:59I think I can never remember if RSI or RDI are the first one, I think I'm going to say RDI is the first

27:05argument, just off the top of my head, I always look that up. So if I wanted to call, let's say give

27:13an integer argument to hello when I originally called it, then from the driver, I literally would just have

27:19to type an integer argument in there. And then under the hood, the RDI register, assuming that I'm right

27:25about RDI being the first argument, the RDI register would get loaded up with that value. And so from

27:31within your assembly program, all you'd have to do is do something with the RDI register, you know,

27:38load it up, save it, do whatever it is that you think you're going to do. So that's how you pass an integer

27:43or like a character or a pointer from C++ to assembly. It works the same exact way if you want

27:50to pass arguments when calling from C to assembly. And if you want to pass integers from assembly to C

28:00or C++, it's the same thing just backwards. First, you load up RDI as the first argument register with

28:07whatever value you want to pass to C or C++. And then in the signature of the C++ function, you just

28:13expect, you know, a long or, you know, whatever you were going to get and the register will already

28:18be loaded up. Remember the C++, it's not really happening on the machine. It gets compiled down

28:23to assembly. So this source code that we're looking at, it's another illusion for our benefit. It's not

28:29happening. It's, it's getting assembled and then compiled down to machine code. And then that is

28:34what's actually happening on the machine. So when you write that you have an argument

28:39in a C++ function signature prototype, you're not really writing that at all. You're just saying

28:46that the A variable should, should get loaded from whatever the RDI register had.

28:52Or if you previously loaded the RDI register and you want to call a C++ function, that's what it would

28:58expect the RDI register. So it can work pretty seamlessly just calling things back and forth.

29:05Um, so yeah, I guess that's all I really had to say.

29:11This is the basics of writing a hybrid program.

29:14Thank you for watching. I hope you learned a little bit of stuff and had a little bit of fun.

29:19See you in the next video.

29:22Hey everybody. Thanks for watching this video again from the bottom of my heart. I really

29:27appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

29:32a small little favor, could you please subscribe and follow this channel or these videos or whatever

29:38it is you do on the current social media website that you're looking at right now. It would really

29:43mean the world to me and it'll help make more videos and grow this community. So we'll be able

29:47to do more videos, longer videos, better videos, or just I'll be able to keep making videos in general.

29:52So please do, do me a kindness and uh, and subscribe. You know,

29:57sometimes I'm sleeping in the middle of the night and I just wake up because I know somebody subscribed

30:01or followed. It just wakes me up and I get filled with joy. That's exactly what happens every single time.

30:07So you could do it as a nice favor to me or you could, you could troll me if you want to just

30:10wake me up in the middle of the night, just subscribe and then I'll, I'll just wake up.

30:14I promise that's what will happen. Also, uh, if you look at the middle of the screen right now,

30:19you should see a QR code, which you can scan in order to go to the website, which I think is also

30:23named somewhere at the bottom of this video. And it'll take you to my main website where you can just

30:28kind of like see all the videos I published and the services and tutorials and things that I offer

30:33and all that good stuff. And, uh, if you have a suggestion for, uh, uh, clarifications or errata,

30:42or just future videos that you want to see, please leave a comment. Or if you just want to say,

30:46Hey, what's up? What's going on? You know, just send me a comment, whatever. I also wake up for

30:50those in the middle of the night. I get, I wake up in a cold sweat and I'm like, it would really,

30:56it really mean the world to me. I would really appreciate it. So again, thank you so much for

31:00watching this video and, um, enjoy the cool music as, as I fade into the darkness,

31:07which is coming for us all.

Mix C++, C, and Assembly into One Program - Hybrid Program Full Build Tutorial

Category

Transcript

Be the first to comment

Recommended