In fact, I have already started writing my own simple kernel, but I still want to know if there is a need to use C++ in practical work.

How to learn C++ in 21 days

Proof of concept: https://github.com/SerenityOS/serenity

I can't believe this is actually exist

Why?

I don't expect people really using C++ for writing Kernel

Well Windows does use it afaik

windows even contains rust implemention of win32k component

That's also apply to -=, +=, /= or even ^=

I don't expect people really using C++ for writing Kernel

The Dark Side sent a code, it has been re-uploaded as a file

guys will that function complete exeuction before compiler executes next line here?

Wat

see the code

So what? The question is not clear

sorry i'm overthinking.. but if there is no explicit thread created in func , it will always complete it's execution before next line executes right ?

Out of context question. What do you guys think about the philosophers problem in C

How to learn C++ in 21 days

Or you can check Jenny's lectures ❤️

Who is it?

what do you mean by your question? you mean how to solve concurrency? or how the problem is defined?

Youtuber teacher

How the problem is defined

Anyone tell me *p++ and(*p)++ difference See here second one will increment value of *p means dereference value But *p++ here why value of p gets increment *p wil first get dereference na

Anyone tell me *p++ and(*p)++ difference See here second one will increment value of *p means dereference value But *p++ here why value of p gets increment *p wil first get dereference na

In *p++, you will have a copy of p used by * and "then" p gets incremented. In (*p)++ after using *p, the post-increment operator will increase what p points to not p itself.

Anyone tell me *p++ and(*p)++ difference See here second one will increment value of *p means dereference value But *p++ here why value of p gets increment *p wil first get dereference na

++ precedence is higher than * so in *p++ first p++ is done and that means p points to the next element and then *p section that means dereferencing the value of p++

U mean p by address or dereference value ?

https://stackoverflow.com/a/15345591

++ precedence is higher than * so in *p++ first p++ is done and that means p points to the next element and then *p section that means dereferencing the value of p++

int p[]{ 1,2,3 }; int* it{ p }; for (int i = 0; i < 3; ++i) std::cout <<*it++ << ' '; std::cout << '\n'; for (int i = 0; i < 3; ++i) std::cout << p[i] << ' '; 1 2 3 1 2 3

Anyone available for 1 to 1 mentoring / pair programming in C and C++, DM me

What is way to merge string such as z= "an"+"ba" in this form without use variables

Anyone available for 1 to 1 mentoring / pair programming in C and C++, DM me

What is way to merge string such as z= "an"+"ba" in this form without use variables

Isnt their any function to sort an array In c will i have to always use bubble sort or selection sort etc?

1. Don't use C 2. Google "qsort"

1. Don't use C 2. Google "qsort"

We still have to write a compare function for that

Can anyone tell me when to use set?

Can anyone tell me when to use set?

Hello friends. Thank you for the C and C Plus Plus books that you introduced on the channel. It was really great. Now I want to learn opengl, do you know a good source?

Just do „an“ „ba“ The compiler will merge these two string literals into one at compile time

Hi. I have a question about data structure alignment in C/C++. Is my understanding correct that individual members are packed if they fit within the word boundaries, rather than each element being aligned to its own word or datatype size boundary? Like this example for a 32-bit system: A B B _ C C C C where B is not aligned, but is contained in a single word, so it still requires just a single memory access, rather than A _ B B C C C C or A _ _ _ B B _ _ C C C C

We still have to write a compare function for that

invalid operands of types ‘const char [3]’ and ‘const char [3]’ to binary ‘operator+’

Only works with direct literals

Alignment requirements are architecture dependent. Assuming that your question is about a specific architecture which has strict alignment requirements where it is illegal to access memory that is not aligned for the type in concern If B is say a char then it doesn't have to be a word aligned (assuming a word is 2 bytes). It can be aligned at any byte and hence doesn't have to have padding bytes inserted before it. However the A before it may require special alignment requirements depending on its type. The alignment requirements most often depend on the type in question. Types like char don't have an alignment requirement while types like short and int require at the minimum a 2 byte alignment while types like long double and long long require 8 byte alignment. If you are doing embedded programming then you may run into special cases where types need to be aligned on a 64 byte boundary or a 128 byte boundary and in other cases even boundaries that are page aligned like for ex 4096 or 8192 byte aligned. In such cases you use the facilities provided by your OS like memalign or posix_memalign to get the correct alignment. So it depends on the type in question

I'm sorry, I should specify. By word I mean the processor word size (32 bits in this example). The sizes of A, B an C are 8, 16 and 32 bits respectively. What I'm wondering is, which of the following will be chosen by the compiler: 1. A, B and C are all 8-bit aligned as long as they fit into a single word boundary (eg. B B _ _, _ B B _ and _ _ B B) are all valid 2. A is 8-bit aligned, B is 16-bit aligned and C is 32-bit aligned (eg. only B B _ _ and _ _ B B) are valid 3. A, B and C are all 32-bit aligned (an entire 32-bit word is reserved for each of the members) I'm specifically curious about which option the compiler will choose on an architecture like x86 where unaligned accesses are allowed, but slower.

Even on architectures where unaligned access is allowed, the compiler is allowed to enforce aligned access because they are faster and also because certain unaligned access instructions can lead to a SEGFAULT on architectures that allow unaligned access. So it is likely that a compiler that sticks to aligned access would choose this A _ B B C C C C for your use case. But this is not the only solution If the compiler can determine that unaligned access for these types won't be a problem then it may even choose A B B C C C C as the packing mechanism albeit at a slower access time cost. So you would have to test the implementation in concern on your own to see what was chosen with different optimisation levels enforced.

> because certain unaligned access instructions can lead to a SEGFAULT on architectures that allow unaligned access Do you mean simd x86 for example?

invalid operands of types ‘const char [3]’ and ‘const char [3]’ to binary ‘operator+’

If you want to have "anba" by "an" + "ba", one way is to use auto z {std::string{"an"} + "bn"};.

Even on architectures where unaligned access is allowed, the compiler is allowed to enforce aligned access because they are faster and also because certain unaligned access instructions can lead to a SEGFAULT on architectures that allow unaligned access. So it is likely that a compiler that sticks to aligned access would choose this A _ B B C C C C for your use case. But this is not the only solution If the compiler can determine that unaligned access for these types won't be a problem then it may even choose A B B C C C C as the packing mechanism albeit at a slower access time cost. So you would have to test the implementation in concern on your own to see what was chosen with different optimisation levels enforced.

Or just "an" "ba"

Alignment requirements are architecture dependent. Assuming that your question is about a specific architecture which has strict alignment requirements where it is illegal to access memory that is not aligned for the type in concern If B is say a char then it doesn't have to be a word aligned (assuming a word is 2 bytes). It can be aligned at any byte and hence doesn't have to have padding bytes inserted before it. However the A before it may require special alignment requirements depending on its type. The alignment requirements most often depend on the type in question. Types like char don't have an alignment requirement while types like short and int require at the minimum a 2 byte alignment while types like long double and long long require 8 byte alignment. If you are doing embedded programming then you may run into special cases where types need to be aligned on a 64 byte boundary or a 128 byte boundary and in other cases even boundaries that are page aligned like for ex 4096 or 8192 byte aligned. In such cases you use the facilities provided by your OS like memalign or posix_memalign to get the correct alignment. So it depends on the type in question