New entry mutable variables

[braanj]

Description

Add new concept entry term for cpp mutable variables.

Issue Solved

Closes #5473

Type of Change

• Adding a new entry

Checklist

• All writings are my own.
• My entry follows the Codecademy Docs style guide.
• My changes generate no new warnings.
• I have performed a self-review of my own writing and code.
• I have checked my entry and corrected any misspellings.
• I have made corresponding changes to the documentation if needed.
• I have confirmed my changes are not being pushed from my forked main branch.
• I have confirmed that I'm pushing from a new branch named after the changes I'm making.
• I have linked any issues that are relevant to this PR in the Issues Solved section.

[braanj]

Hey @codecademy-docs please review

[braanj]

Hey @Sriparno08 please review

[Sriparno08]

Hey @braanj, I'll review this by the end of the week.

[Sriparno08]

Hey @braanj, thank you for contributing to Codecademy Docs!

I've listed all the modifications that you need to make in your entry below:

[Sriparno08]

Modifications:

• Let's write the title in title case
• Let's change the description a bit
• Let's add some more tags

Suggested change

	---
	Title: 'Mutable variables'
	Description: 'In C++, the `mutable` keyword in C++ allows certain class variables to be modified even within const functions, useful for managing internal state flexibly.'
	Subjects:
	- 'Computer Science'
	- 'Game Development'
	Tags:
	- 'Variables'
	CatalogContent:
	- 'learn-c-plus-plus'
	- 'paths/computer-science'
	---
	---
	Title: 'Mutable Variables'
	Description: 'Mutable variables are variables that can be modified even within constant functions.'
	Subjects:
	- 'Computer Science'
	- 'Game Development'
	Tags:
	- 'Functions'
	- 'Values'
	- 'Variable Types'
	- 'Variables'
	CatalogContent:
	- 'learn-c-plus-plus'
	- 'paths/computer-science'
	---

[Sriparno08]

Let's make some minor changes:

Suggested change

	In C++, the `mutable` keyword in C++ allows certain class variables to be modified even within const functions, useful for managing internal state flexibly.
	In C++, mutable variables are variables that can be modified even within constant functions, useful for managing internal state flexibly.

[Sriparno08]

Let's make some minor changes:

Suggested change

	To declare a variable as `mutable`, simply place the `mutable` keyword before the variable type:
	To declare a variable as mutable, the `mutable` keyword needs to be placed before the variable type:

[Sriparno08]

Let's make some minor changes:

Suggested change

	- **type** - The type of the variable (e.g., `int`, `char`).
	- **name** - The name of the variable.
	- `type`: The type of the variable (e.g., `int`, `char`).
	- `name`: The name of the variable.

[Sriparno08]

Let's make some minor changes:

Suggested change

	In the example below, `accessCount` is marked `mutable`, allowing it to be modified within the const `displayData` function:
	In the example below, `accessCount` is marked `mutable`, allowing it to be modified within the constant `displayData()` function:

[Sriparno08]

Let's change the indentation to 2 spaces and make some minor changes:

Suggested change

	```cpp
	#include <iostream>
	#include <string>
	class Data {
	public:
	Data(std::string value) : data(value), accessCount(0) {}
	void displayData() const {
	++accessCount; // Allowed modification due to `mutable`
	std::cout << "Data: " << data << ", Access count: " << accessCount << std::endl;
	}
	private:
	std::string data;
	mutable int accessCount; // Can be modified in const methods
	};
	int main() {
	Data d("Sample");
	d.displayData();
	d.displayData();
	return 0;
	}
	```
	```cpp
	#include <iostream>
	#include <string>
	class Data {
	public:
	Data(std::string value) : data(value), accessCount(0) {}
	void displayData() const {
	++accessCount; // Modification allowed due to 'mutable'
	std::cout << "Data: " << data << ", Access count: " << accessCount << std::endl;
	}
	private:
	std::string data;
	mutable int accessCount; // Can be modified in constant methods
	};
	int main() {
	Data d("Sample");
	d.displayData();
	d.displayData();
	return 0;
	}
	```

[Sriparno08]

Let's add a sentence to introduce the output:

Suggested change

	```shell
	Data: Sample, Access count: 1
	Data: Sample, Access count: 2
	```
	The above code produces the following output:
	```shell
	Data: Sample, Access count: 1
	Data: Sample, Access count: 2
	```

[Sriparno08]

Let's make some minor changes:

Suggested change

	Here, even though `displayData` is a const member function, `accessCount` can be incremented due to its `mutable` declaration.
	Here, even though `displayData()` is a constant member function, `accessCount` can be incremented due to its `mutable` declaration.

[Sriparno08]

Let's change the sentence:

Suggested change

	Use this example to experiment with mutable variables in C++. Enjoy coding!
	The following codebyte example demonstrates the usage of mutable variables:

[Sriparno08]

Let's change the indentation to 2 spaces and make some minor changes:

Suggested change

	```codebyte/cpp
	#include <iostream>
	class Counter {
	public:
	Counter() : count(0) {}
	void increment() const {
	++count; // count is mutable, so this modification is allowed in const method
	}
	int getCount() const {
	return count;
	}
	private:
	mutable int count;
	};
	int main() {
	Counter counter;
	counter.increment();
	counter.increment();
	std::cout << "Count: " << counter.getCount() << std::endl;
	return 0;
	}
	```
	```codebyte/cpp
	#include <iostream>
	class Counter {
	public:
	Counter() : count(0) {}
	void increment() const {
	++count; // 'count' is mutable, so this modification is allowed in this constant method
	}
	int getCount() const {
	return count;
	}
	private:
	mutable int count;
	};
	int main() {
	Counter counter;
	counter.increment();
	counter.increment();
	std::cout << "Count: " << counter.getCount() << std::endl;
	return 0;
	}
	```