I am literally constantly confused by literals and constants!

Yes, please make a video explaining "pages, offsets, and how that all works". It's especially interesting how you accessed the page at time index 9:00. A more detailed explanation about that would be appreciated. Great content as usual, thanks.

On an embedded system it is very normal to have const volatile variables. Mostly these are const volatile pointers, for example const volatile uint32t *ptr; These (points to) memory mapped I/O registers that are read-only registers like a status register. No way that the program can change them but the hardware can and will do. From the program point of view the register is read-only/immutable, not constant. Note: this is the same for hardware drivers on a PC. I don't think it is undefined behavior this way, with volatile.

You can actually redefine a #define , without throwing warnings by literally undefining it using #undef before #defining it again

The way you masked off those bits to get the address of the page is extremely interesting! And indeed, I'd love to see more content about stuff like this.

Just read a few confusing comments about this somewhere and you made a video for it, great timing thanks 🌟

wow...analysing const in such a depth...really good...❤

defiantly Needed jacob, pages,offset,memory management..

Thanks, this video was very useful to me. Sometimes, different languages use the same word to indicate different things, or different words to say the same thing, and then it happens that you get confused even on trivial things. Maybe when I work at a low level I should forget all abstractions and just focus on the machine.

First let me say, you rock! I know I may have been one of the people who came off as a naysayer, but I think part of it was me stuck on the "not a constant" versus listening to what you were actually talking about, of which I understand now with this video. Kudos fine sir!

Thank you for more information, I look forward to more deep dives into why bits bang the way they do ;)

In my experiment this also works without having to get the page starting address. Just modify A's memory protection instead of the whole page. void *p = (void *)((uintptr_t)&A); mprotect(p, 2, PROT_READ | PROT_WRITE);

Haha nice. Programming comedy, love it. You learn a lot while having fun, like all types of comedy.

From what I can see, the compiler is treating a “const” as an unchangable value which is a constant. While it might be possible to change a const using some esoteric method, for those of us interested in writing and maintaining good C code, a const can legitimately be thought of as a constant.

I love computers. Thank you for teaching me so many things, friend!

Good job Jacob.

Excellent video, thank you!

Wow fascinating. Thanks!

Not want to use enumeration constant for an array size: we used to! Enums predate `const` and other features, and were abused to provide properly scoped constant names (that is, not preprocessor symbols) for quite a while. If i recall correctly, when `const` was added to C, it still was not a constant expression like in C++, so you could not use a `const int ArraySize=64;` as a (regular) array size. Though now that silently creates a variable-sized array. When I learned K&R C in the 80's, function definitions looked different, there was no `void` keyword, and all structure fields had to be unique rather than the name scoped to that structure! And you could use the wrong name with an -> and it just uses that offset without complaint.

Please can someone give advice of how to effectively deprecate functions in a C library which is living in the wild? Love the videos btw, it's really helping me in my journey to become a more aware programmer.

Really interesting, thanks! Would the compiler still put the variable in read only memory if it's volatile const?

I would love a video about “pages, offsets, and how that all works”!

I'm curious what you think of the additions to C coming in C23, constexpr might be interesting, and I kind of love #embed.

7:38 Wouldn't that be the job of the loader? The compiler and linker put the constant in the read only section of the binary, but the actual protection of the region has to be done by the operating system (loader?).

This reminds me of my successful efforts to bring properties to C++ from Pascal.

int main(int argc, char **argv) { const int a = 10; *(int*)&a = 5; return printf("%d ", a); // no segfault ('a' is on the stack) }

Hi Jacob. Could you please make a video about Red-Black Trees? I'm really struggling with it

is there some compiler flag to disable replacing const variables with their value?

Even with 0 optimization would the compiler pass over the memory trick?

this video was just amazing but it left me craving for a video about masking bits

Maybe I am remembering wrong, but I think I used "volatile const" for inputregisters on my μController because writing to them would mess up a whole bunch of code and i had to specifically tell the compiler that it had to check every time (yes the compiler was very weak)

What is the definition of a constant in native programming anyway? Mayne only values that only can get folded in as an immediate value in assembly. This means that constexpr in C++ does not define a constant, since it is legal to take the address of such an object. But a consteval (c++20) function is.

Also makes me wonder how the behavior would change depending on where the compiler places static const variables...I think that's in bss rather than an rodata region?

Const-qualified variables can't be interpreted as constant expressions as the value doesn't have to be provided at compile time. It is for locals for but not for parameters for example. void f(int const n) { // n is readonly, not constant. } int main(void) { f(rand()); } This compiles because regular values can be "promoted" to const.

Trivia question: how do you express the decimal integer literal of value zero in C?

I think you've confused more people with meddling with memory protection like this :) What I mean is people may think this is how it should be done, that "const" doesn't really mean constant and so it can be modified by finding the page base address and fiddling with its protection bits.

The source of the confusion is likely C++ const. In C++ a const variable CAN be used as a constant expression if it is initialized with a constant expression, so it is a constant. (Or at least as much of a constant as the context allows it to.) Not only that but it is taught and recommended to use const (or constexpr since C++11) over #define because #define can cause issues with overload resolution and other type-sensitive issues. #define constants are pretty much obsolete in C++, but still an important part of the C language.

Question: would #define be faster than const since instead of retrieving data from the const variable , the machine has direct access to the value

When you print an address using %p, the output is something like 0xabcdH. Aren't the prefix 0x and the suffix H redundant? Don't they both mean hex?

While it is true that a #define can be redefined, that's only true statically. B would actually be constant at runtime, as something like "B = 7 "would not be a valid expression.

try to cast its address in the printf..

I'm really curious if the generated assembly would actually read from that memory address without needing to mark the variable as volatile if optimizations were turned off with -O0. Off to Godbolt, I suppose.

The use of the const keyword does not say anything about the constness of an object. It just reflect the intention of the programmee/code not to change that object. If the compiler believes you, it can create an constant object for you (in for example read-only memory). We can have a const pointer to a non const object. You can pass either the address of a const object or the address of a non const object to a function that have a const pointer as argument. For example strlen() What should be the output of the following code: int a; const int *p = &a; a = 10; printf("%d ", *p); a = 5; printf("%d ", *p); Is this correct code? Or should p defined as: const volatile int *p; ? (Did not tried this code (yet).)

ممتاز شكرا لك👍

@7:40 something - (under linux) It has nothing to do with mprotect or mmap (well, actually mmap yes since that's how the elf loader uses an ELF binary) ! It's simply that the constant it located in a read-only segment in the ELF file (usually in the .text segment). And please, please please.. the issue is that you are using a feature of C which is specifically defined as "undefined" : you are breaking the strict aliasing rule ! (turning a const int * into an int *). In C it's as simple as this : symbol with the const qualifier should not and cannot be used as an Rvalue but only as an Lvalue ! Casting of symbols should only be applied to 'void *' - something used to move around opaque structure pointers. Also any reasonable compiler optimizer will just treat a const symbol as a literal if it knows the value. Note that using gcc (and to demonstrate it's VERY undefined.. ) : $ cat t1.c #include static const int A=1; int main() { int *b; b=(int *)&A; *b=2; printf("A=%d,%d ",A,*b); } $ gcc -O3 -Wall t1.c -o t1 $ ./t1 A=1,1 $ * It's obvious that through SSA optimization the C compiler understood we were talking about A all along and just discarded the *b=2 ! Looking at the generated x64 generated code it's just using literal 1 throughout ! $ gcc -Wall t1.c -o t1 $ ./t1 Segmentation fault $ * No optimization.. So it just went ahead.. and wrote to a protected segment ! Then you can make the symbol volatile - hilarity ensues ! Remember.. C is just a glorified assembler.. compilers will attempt to detect through its (somewhat heuristic) logic if you are trying to do something stupid - but you can always fool it ! If you *REALLY* want to shoot yourself in the foot using convoluted and obfuscating methods, it will eventually relent and let you (for example there are times you really intend to do something specific with a very specific compiler on a specific architecture and you know it's going to behave a certain way).

C programmer: God why can't I have a language with a constant variable Meanwhile assembly programmers having an unspoken argument with 100 other programmers that none of them will change the value of a variable

ahh so usually a readonly variable is actually stored in memory, it can be assigned by values that change during run time and constant variables are assigned at compile time and are not read from memory, and because C has no standardized behaviour for const in this case it is treating it as a constant value and in other cases at readonly values? did i get that right? sorry im still kinda confused by all that :D

I'm not a C programmer. I use C++ so a lot of C stuff I don't know. I watch this channel for its C++ centered content (of which there is very little of, we need more), but it's cool to passively learn about the C language too.

"Unless the program rewrite its code in Memory"... Is that really possibile for a program to rewrite its own code while running? It would be Amazing to see a video about

my windows pc gives this output, pretty cool a=100, &a=0xec065ffcf4 *p=500, p=0xec065ffcf4 length of int arr[a]=100

Occam's razor: just let and keep the meaning const = constant.

You can redefine anything with meta programming 😀. Macros without redefine or undef, const or what ever actually. Make dll, have program call into that, recompile dll with new name and swap. Before compiling dll, look for the macro or const and change the value in the source file, with some parsing program, a pre pre processor if you will. Bam, changed during runtime of the program and not UB. TADA! Can be done by a keyboard press. Well, after you've made the meta stuff and the hot reloading. Super good debug/development iterative magic voodoo

const != constant

cool

Moral of the story: Don't use assembly if you need some akin to a "constant" value

What about us C/C++ nerds? Will you listen to us and stop using C-style code in C++ programs?

So const is constant in pretty much all cases. :P

Meaning "#define MAX_X 10" doesn't use up memory, while "const int MAX_X = 10;", does. And, as it seems in a useless way. My vote is for the "#define". I know, I know, a handful of bytes doesn't even worth the mention when programming for a desktop with RAM measured in GBs. But go use unnecessary "const variables" like that in a small micro controller with a few KB of flash and almost one KB of RAM. Yes, yes, yes. You can get a micro with 3 or 4 times the amount of memory for a few more cents....... ......a few more cents multiplied by one million units a year during a 10 year product cycle, for example. My vote still goes to "#define" for avoiding "magic numbers" in the code and easy tuning of the program features. After all I also use a lot of "#define" statement in the main header file of my projects just for selective compilation of functionalities in the code. It makes modular testing and debugging way more easy than having to deal with a monolithic beast. Nevertheless, I think the "const" keyword deserves its own dedicated video because it has a lot of use cases that are not always that clear. And can cause noobs some headaches when dealing with libraries where it is highly used.

Anyone ever tell you that you look like the coolest System Lord?

In this video we watch C doing everything to make that const int a constant... yet people still can say "there are no constants in C". Geez!

6:55 You are invoking Undefined Behavior. You did say not to try this on programs we care about, but really this might lead to bizarre results if you optimize.

So, basically, nowadays const means constant in C. Good to know!

Like your videos but don't really see the sense of it. Is this only in terms of philosophy?^)