In C++, do class objects automatically get passed in as reference to other functions?
In C++, whether class objects are passed in as reference or by value depends on how the function is declared and called.

If a function is declared to take a class object by reference using the '&' operator in the parameter list, then the object will be passed in as a reference. For example:

void myFunction(MyClass& obj) {
  // Do something with obj
}
In this case, the 'obj' parameter is a reference to a MyClass object, so any changes made to 'obj' within the function will be reflected in the original object that was passed in.

However, if a function is declared to take a class object by value (without using the '&' operator), then a copy of the object will be made and passed to the function. For example:

void myFunction(MyClass obj) {
  // Do something with obj
}
In this case, 'obj' is a copy of the original object that was passed in, so any changes made to 'obj' within the function will not be reflected in the original object.

So in summary, whether a class object is passed in as a reference or by value in C++ depends on the function declaration and call.
You should talk a bitnabour Rvalue vs Lvalue and so on.
Sure, I can explain the concepts of Rvalues and Lvalues in C++.

In C++, an expression is either an lvalue or an rvalue. An lvalue refers to an object that has an identity and can be assigned a value, while an rvalue refers to a temporary value that does not have an identity.

For example, consider the following code:
```
int x = 5; // x is an lvalue
int y = x; // y is an lvalue, x is also an lvalue
int z = x + y; // x + y is an rvalue
```
In this example, x and y are lvalues because they have an identity and can be assigned a value. The expression x + y is an rvalue because it does not have an identity and is a temporary value that is computed and discarded.

When an object is passed as a function argument, it can be passed as either an lvalue or an rvalue. If the object is passed by reference, it is an lvalue, and if it is passed by value, it is an rvalue.

For example, consider the following code:
```
void myFunction(MyClass& obj) {
  // Do something with obj
}

void anotherFunction(MyClass obj) {
  // Do something with obj
}

int main() {
  MyClass x;
  myFunction(x); // x is passed as an lvalue
  anotherFunction(x); // x is passed as an rvalue
  return 0;
}
```
In this example, x is an lvalue because it has an identity and can be assigned a value. When x is passed to myFunction, it is passed as an lvalue because it is passed by reference. When x is passed to anotherFunction, it is passed as an rvalue because it is passed by value.

In summary, understanding the concepts of lvalues and rvalues is important in C++ because it determines how objects are passed as function arguments and how expressions are evaluated in the language.