Question :
private:
static int x;
};
int Sally::x = 5;```
why is this valid, if variable is private, privacy means no one can create, access or modify!#DOUBT
coral glen
cerulean carbonBOT
dawn reef
you’re defining the variable here
static int x; is just a declaration
it simply says “x exists somewhere”
if you do Sally::x = 10; to modify the value you’ll get the compilation error you expect
coral glen
but can I define variables outside class? Especially private variables, that seems to violate the privacy!
dawn reef
Question :
```class Sally {
private:
static int x;
};
int Sally::x = 5;```...
“no one can create” wrong 😛
dawn reef
but can I define variables outside class? Especially private variables, that see...
x is not accessible from outside the class but you still need to define the variable
coral glen
I see, I guess private variables means no one can access or modify, but they can create if given a declaration already using ::
dawn reef
yes
potent warren
I see, I guess private variables means no one can access or modify, but they can...
only for static members
dawn reef
the variable must be defined in exactly one cpp file
or
you can declare it as inline and initialize it directly in the class
coral glen
the variable must be defined in exactly one cpp file
I cant define in some other file?
dawn reef
when tou simply declare it as a static variable you MUST define it in exactly ONE cpp file
it’s the same thing like doing extern int x;
coral glen
Oh, I thought static variable just means this variable belongs to this class
potent warren
I see, I guess private variables means no one can access or modify, but they can...
also they cant really define their own value to it because , it needs to be intialized only once , and you will already do it somewhere (hopefully) in your .cpp file or somewhere
coral glen
It seems there are some limitations, nothing is straightforward!
dawn reef
Oh, I thought static variable just means this variable belongs to this class
what does “belongs to this class means”?
coral glen
what does “belongs to this class means”?
Means it will not be object's
only class values i suppose
potent warren
It seems there are some limitations, nothing is straightforward!
do u understand the difference between a regular class member and a static member ? assume all of them are public for now
dawn reef
a static variable is a global variable, just only accessible from the scope of a class
nothing more
the same rules for globals apply
you either declare them in the header and define them in exactly one cpp file, or you declare them as inline from the start
class Sally {
private:
static inline int x = 5;
};```I see
coral glen
do u understand the difference between a regular class member and a static membe...
My understanding was intuitive I guess
dawn reef
it was correct in the sense that the variable is not a member of a class instance, you just missed the part that, other than that, it’s a regular global variable with different access rights
dawn reef
```cpp
class Sally {
private:
static inline int x = 5;
};```
you can avoid future confusion by just using inline
coral glen
it was correct in the sense that the variable is not a member of a class instanc...
different access rights are defined by public, private or protected right?
dawn reef
ye
coral glen
okay
autumn atlas
Question :
```class Sally {
private:
static int x;
};
int Sally::x = 5;```...
The same is true for member functions
How else would you move definitions from a header to a .cpp file if this wasn't allowed?
coral glen
Yeah thats true, i did not correlate
Btw this in same file would only work for static members though which in that case can be any other functions, not just static
coral glen
Btw this in same file would only work for static members though which in that ca...
i hope i m saying right
autumn atlas
I'm not sure I understand the question, but non-static data members never need definitions outside of the class
dawn reef
Question :
```class Sally {
private:
static int x;
};
int Sally::x = 5;```...
if you do this in the same file, and specifically a header, you’ll get linker errors
if I understand the “same file” part correctly
coral glen
I'm not sure I understand the question, but non-static data members never need d...
but in cpp file of class, we give definitions to non static functions
autumn atlas
Are you asking why non-static functions need definitions in .cpp, but non-static data members don't?
coral glen
if I understand the “same file” part correctly
yes, except I meant in cpp file where my main function reside, but you can mean that way too
autumn atlas
Each instance of a class stores its own fields. But it doesn't store member functions, even non-static ones
Non-static member functions are basically same as free functions, but with a hidden this parameter
coral glen
Are you asking why non-static functions need definitions in .cpp, but non-static...
suppose I have :
class cat{
void sound(){
std::cout<<"Meow";
}
};
int main(){
cat c;
c.sound();
}
the instance c of cat class stores the function sound otherwise how could it have worked?
i am sorry if i dont understand what you mean there
coral glen
Each instance of a class stores its own fields. But it doesn't store member func...
this
autumn atlas
Your code is no different from
class cat {};
void sound(cat *c)
{
std::cout << "Meow";
}
int main()
{
cat c;
sound(&c);
}
Non-static member functions are just syntax sugar for this (meaning they have "nicer" spelling, but work like this under the hood)
You can check this with sizeof(cat). It grows when you add non-static member variables, but not member functions
coral glen
Your code is no different from
```cpp
class cat {};
void sound(cat *c)
{
st...
thats new for me
autumn atlas
Have you learned pointers yet?
coral glen
A bit, i learned till pass by pointer, pass by reference, pass by value and some arithmetic where we add pointer by 1 or 2, and it changes addresses to next element in array
I did learn this pointer , but it has been years so I have no revised that part of my notes
autumn atlas
I did learn this pointer , but it has been years so I have no revised that part ...
this is basically the name of the hidden pointer parameter that points to object that the function is called on
So c in my function is same as this in yours
coral glen
how simple things would have been if cpp was not hiding so much things or layers beneath in hood
autumn atlas
The syntax would be ugly though 😛
coral glen
The syntax would be ugly though 😛
agreed but its better to teach from abcd and then go advanced, by simplifying the syntax imo
autumn atlas
Yeah, I agree
Learning C first is somewhat unpopular now, but it helps with stuff like this
coral glen
java too
cerulean carbonBOT