For people having trouble remembering the order in which const keyword is to be used, here's a quick tip. You have to read it backward, like the compiler does. For instance : -const int * A; ==> "A is a pointer to an int that is constant." (or, depending on how you prefer to write it) int const* A; ==> "A is a pointer to a const int" but both are the same as explained in the video. -int * const A; ==> "A is a const pointer to an int." -const int* const A; ==> "A is a const pointer to an int that is constant". EDIT : As mentionned by simo simo in the comments bellow, const int * A does not mean that A actually points to a const variable. It just means that the compiler will not allow you to modify the pointed value *through* A. for instance : int val = 10; int const * a = &val; *a = 30; //this will NOT compile, you're not allowed to modify "val" through "a". val = 30; //this will compile. Same with : int val = 10; int val2 = 30; const int * const A = &val; A = &val2; //will NOT compile : you can't modify what A points to. *A = 30; //will NOT compile : you can't modify val through A val = 30; //this will compile, val is not constant
Funny short story, demonstrating all acquired Cherno-skills: I went ahead and compiled the code showed on 2:53. I wanted to see *if I could force a change to the const MAX_AGE using the a pointer* . *The code:* _const int MAX_AGE = 90;_ _int* a = new int;_ _a = (int*)&MAX_AGE;_ _*a = 85;_ _std::cout
"const is basically sort of like a promise that you give, in which you promised that something will be constant, that is it's not going to change. However, it's just a promise and you can bypass that whole 'promise', and you can break your promise just like you can in real life." I came here to learn more about C++ but I get legit life lesson instead...
Personal notes: - reading backwards helps understanding what is constant - making a class method constant says that that method will not change any of the class member - defining a function outside of the class and passing class instance as a constant reference makes sure that the instance won’t change. Thus, any method in that function must be const, otherwise you get error
For anyone still struggling. A good way to read these statements is from right to left. Example: const int * (pointer to an int constant), int const * (pointer to a constant int), int * const (constant pointer to an int), const int* const (constant pointer to a constant integer)
Man! I never understand this const properly. I learned everything I could find in books, lectures and other c & c++ videos on RU-vid. But this is the only video that solved all of my confusion on const. Thanks a lot man.
If people like, please visit his patreon page. I will certainly be contributing come 1st of next month. As I think u get a months benefit from start of each month.
@@thomascreel6522 That's true for all arrays. As soon as you change the size, you reassign it with a different array, so it's no longer the same array with the old size. Now, of course, const prevents that and only that.
@@cvbattum No, the number of elements in the array is immutable and you must create a new array of a different size and move the old array elements into it.
/* my note of CONST Use for 3 cases */ 1. const int* a => can't modify the value store in a (address) 2. int* const a => can't modify the address which a points to 3.use in member function which promise not to modify the data member of the class => add const to all member functions which don't modify data members , since it might be const reference! p.s. add "mutable" if you want to break the promise wrap up const int* const Getter() consr {}
schools teach and test programming using the worse method and discouraging students so much. In my C++ course i thought about droping the class so many times bcuz of my mark, on the other side i have good understanding on C++. It never makes sense bcuz schools care for mark and never for the diamond someone got in his brain
Harold Finch because when my mother language is not English and the question in a test is a paragraph long asking to write a single line code. That’s when I start making mistakes. Programming instructors are not often found in every school
dont forget that const makes a variable local to the file. that is, only visible in the actual translation unit. you can have 2 const variables with the same name in different files and it will compile fine. so basically they re implicitly static.
You are seriously the best code teacher I've seen and I bought something like fifty udemy courses.. keep the good work and combining assembly and c++ together! Its great and im learning alot even as a long time java programmer! Thank you a lot!!!
***EASY MENTAL MODEL TO PERMANENTLY REMEMBER THESE*** think of '*' as boundary, whatever is in contact with const is meant to be constant eg1: int const *ptr -> int const |*| ptr eg2: const int *ptr -> const int |*| ptr -> const is in contact with int only, and ptr is separated thanks to boundry '*', this means: 1. we can't modify int values 2. we can modify pointer eg3: int * const ptr; -> int |*| const ptr -> const is in contact with ptr while int is separated, this means: 1. we can't modify pointer. 2. we can modify int values. Also You can read backwards as suggested by @Jean-Nay Mar
Thank you for all your videos! I just finished working through a C++ book, and I'm at the point where I try to make my first "thing," and I go "uh oh I still don't know anything." These videos are excellent for solidifying my understanding of things that I remember reading about, but do not yet have an instinct to know if I'm using them correctly yet in my own work.
@@kushnayak1619 I want to know the mindset that led you to write "ok" and I also want to know the mindset that led somebody to give you a like after at most 8 hours. Because I want to benefit from the law of attraction fully.
@@kushnayak1619 So I guess the answer is: You don't really want to benefit from the law of attraction. What a pity. I want to inform you that I am very cool.
@@kushnayak1619 And also, to all the other people: It looks like you are liking your own comments because you got one like again after 23 minutes. This feels like a psychological disease to me, right now :) - Correct me if I'm wrong. Plausible. Try.
Hey, I saw just two videos and clicked the sub button , your videos are really high quality and I left with a lot of answers than questions when I finish watching . Keep up the hard work . Cheers .
Pretty clear, thank you. It should be noted, if a global variable is declared as "const" or a variable is declared "static const", then it is placed by the linker into a non writable CODE or CONST segment. When it is written to by some pointer trickery, an access violation exception will probably happen.
since people are still watching/commenting. A great example why const on member functions should be used. map[ ] operator (as in dict["key"] = value. it's sometimes (depending on the implementation of map) not const. So this dict["kye"] = value would compile and work, until it doesn't because you just inserted >value< at "kye". If you don't know the framework in&out, be const correct. This particular thing was taken from the yt-video: c++ bugs at facebook.
In some ways the opposite is true. If you get const right in your program, you'll have to worry less about what you do with your objects. Without const it would be like having a bunch of global variables that might get changed without warning. With const, I can give you an const object and not worry about you changing it...like a map's key.
"If you want both members to be pointers, you have to put the asterisk before every member" - this is why every programmer should immediately adopt my style of placing pointer asterisks on the name side instead of the type side! Then it works perfectly when you define multiple pointers on one line. Well, until you try to define a function that returns a pointer, then your asterisk doesn't know where it wants to be. "We still need to mark the method as const, but we just want to touch this variable" - a good example of when this pops up a lot is in "on demand" situations, such as load-on-demand, where an object loads its data in the background the first time it is required. In such a case, it is usually necessary to modify the object from a const situation, even though the method itself is not really the purpose of the modification, just the reason it is needed.
bro your channel is a gold mine i just started learning C++ also new to programming but your vids help alot. would love to see u do games like asteroids and snake etc with C++
You really did make me understand what const's are and how do they work, have been trying to find answer to it from so many websites and videos I can't believe I now understood it all. Really thank you so much!!
So if I understand it right, writing const before a pointer means the data at that pointer is cannot be modified, after a pointer means the pointer itself is constant but the data at that memory address can be rewritten, and both before and after makes that pointer completely read-only, you cannot redefine the pointer itself nor write to the data at the memory address it points to, that's pretty useful to know. As an experiment I wrote a # define (had to put a space between # and define to keep RU-vid from treating it as a hashtag) to see if I have a solid understanding of it, if anyone is curious here's what I wrote: # define readonlyptr(T) const T* const
Question: How come we can change a const char* value? And don't even have to de-refference it? const char* example = "Some text."; example = "Some different text."; //didn't have to type * before example, and it allows us to change the value despite being an array of const chars? Thanks for all your videos! You're the best teacher I've come across on these subjects!
const applies to the thing left of it. If there is nothing on the left then it applies to the thing right of it. Object * const obj; // read right-to-left: const pointer to Object Object const * obj; // read right-to-left: pointer to const Object Object const * const obj; // read right-to-left: const pointer to const Object
Fantastic video Cherno as usual, thank-you for uploading! What is your opinion on using const everywhere possible? I came across big flame war on StackOverflow recently between people that supported the 'security' and 'consistency' of using const wherever physically possible and those that said it was an eyesore. We're talking about using const literally everywhere - a simple 2 line function that takes in one integer to use in some quick calculation? It must take in a const int because the value is not modified. Would you say it is an eyesore to have it everywhere or do you think there is some benefit?
Really nice tutorial, I already know C++ and I just ran across this, but it still cleared a couple of things up, in terms of the mutable keyword at whatnot. I will probably keep watching these in case there is anything else I missed :) :)!!
if you are planning to work with classes, assigning objects to one another and "return" object types then the CONST keyword is one of the few things you must know. Some places where you NEED to use const copy constructor, code: {className(const className &object); } assignment =("is equal to" symbol) overloaded operator, code: {void operator=(const className &object); }
You should make some videos on specific Design Patterns, in particular (for me) the Strategy Pattern in C++. Maybe, recommend some books for learning the main Design Patterns every programmer should know ...
The question is why in C++ you generally put * (pointer token) next to the identifier instead of next to the type. It would make more sense to me if it was placed next to the type.
@@Katniss218 One reason is that if you define multiple variables on the same line, like: "int* a, b;" , b is actually not a pointer. So by declaring your pointers like: "int *a, *b;" it makes it easier not to make this mistake, and the first example can be a bit misleading, especially for a beginner. Of course you could just declare your variables on a one-per-line basis.
@@givup_ And that's really stupid and unintuitive design. If I were designing the C++ specs, I'd do it so that both a and b would become pointers. And if you don't want that, just initialize each variable on it's own.
@Peterolen I wonder why it was the standard in C then. It's *very* counter-intuitive to beginners and makes the code less readable (imo). I'm glad I'm not forced to use it.
in a function, when should we pass as pointer and when should we pass as reference? For example the PrintEntity function could have argument (Entity *e) or (Entity &e) what should be used when
Only problem is that references are already "hard pointers", so "const int& *_const_* p1" doesn't work (2+ years old comment, and 4+ year old video, though for some reason I ended up here)
//QUESTION: (THIS SEEMS TO BE A BUG IN VS/VisC++) // Where in the hell are the two different // numbers being stored? const int j = 100; //int *q = &j; //Compiler disallows int *q = (int*)&j; //By some magic, now allowed *q = 300; //After this line, j = 300 in debugger cout
0:16 Why doesn't the compiler use the fact that a variable is const for optimization? This would only work if it weren't a promise of course. An example that could be optimized: const int SCALAR = 90; int x = 2 * SCALAR * y; If the compiler knows that SCALAR is constant, it could calculate `2 * SCALAR` at compile time and would only have to do one multiplication at runtime. Or does it do that already, just by being clever and recognizing constant variables even without the const keyword?
at 2:50 why you cast into (int*) instead of (int)? I mean sure, it doesn't compile when using (int) but *why* do we need or what's the reason of casting into an int*?
Now I still have a question, why would I want to use const in the first place? Like, does the compiled code gets any faster, or is it just a restriction to myself?
I played around with this. With just const int MAX_AGE and int* a, I don't understand why I can assign the address of MAX_AGE to a, then modify the contents of a, and printing both a and &MAX_AGE shows they are equal, yet the contents of a no longer equal MAX_AGE. On the other hand, *a and *&MAX_AGE both equal the new contents of a. It makes my head swim.
@@czarcarlo5459 actually I found the answer yesterday sir. What's happening is, Use your debugging feature and breakpoints, you'll see after the the pointers value is changed, the value of memory of MAX_AGE is changed too. Means we were successful, and the memory which contains MAX_AGE has been changed, yet we continue to get same result. Why?? Because, if you check the assebmly code, you'll notice that after program was compiled, the compiler replaced the MAX_AGE everywhere with the value 90 itself, during compile time itself to not keep extra variable. Hence cout
@@thanostitan.infinity Ah dude, Thanks man. I found that If I do this in C printf-ting it displays the right value after modifying So at the end its the C++ compiler being too clever? Is this a bug?
9:50 I'm confuse, if by using a reference I can't change the contents of the class variables then what about the talk of using references instead of pointers to change variable contents? Object references can't call any function of the respective class whenever a variable of that class is changed by that function, is that it?
if my member is a pointer, should I always write the getter as const type* const getMember() const{ return member;} ? or with const befor {} is enough?
Few things, for embedded. const char* str = "Hello World"; will place those 12 bytes in ROM while char* str = "Hello World"; will place those bytes in ROM and RAM. Btw. I don't get it why I cannot call const func from class if it reference isn't const.
int *myX; const int * const getX() const{return myX;} 1 - return (pointer cant be modified) 2 - contents of pointer cannot be modified 3 - getX not modify actual class
I thought when you assign a pointer to some value that the copiler sets aside memory for both the pointer and the actual thing being pointed to. If I reassign the pointer and later delete it then i still have 'that original value' still dangling out there somewhere. I was told, it is best to assign a pointer and delete it then recreate and assign again. ... or just use two pointers for as long as you need them.
