Tokens in C++

Understanding C++ Tokens: The Core of Your Code

C++ tokens are the smallest pieces of a program that the compiler understands. They're like the individual words in a sentence, coming together to create meaningful code. If you're new to C++ or brushing up, knowing tokens is key to writing programs that work.

Since C++ builds on C, it shares many of the same tokens, expressions, and data types. This makes it easier for C programmers to jump into C++. Let’s dive into the main types of tokens and explain what they do in a clear, practical way.

The tokens are:

• Keywords
• Identifiers
• Constants
• Variables
• Operators
• Punctuation

Keywords: The Commands of C++

Keywords are reserved words with special meanings. The compiler knows exactly what they do, and you can’t use them for anything else. C++ has more keywords than C, especially for features like object-oriented programming.

Here’s a quick look at some common ones and what they’re for:

• Control Flow: if, else, switch, case, break, continue, return, goto – These control how your program runs, like deciding which code to execute or when to stop a loop.

• Data Types: int, char, double, float, bool, void, long, short – These define what kind of data your program works with, like numbers or text.

• Storage Classes: static, extern, mutable, register, volatile – These tell the compiler how to store variables, like keeping them alive longer or sharing them across files.

• Object-Oriented: class, struct, public, private, protected, virtual, this, friend – These help you create and manage objects, a big part of C++’s power.

• Others: namespace, using, typedef, const, sizeof, typeid, template, new, delete – These handle things like organizing code or managing memory.

For example, if lets you run code only if a condition is true, while class sets up a blueprint for objects. Knowing these helps you tell the compiler what to do.

Identifiers: Naming Your Code

Identifiers are the names you give to things like variables, functions, or classes. They’re how you refer to different parts of your program. Each one needs to be unique so the compiler doesn’t get confused.

Rules for naming identifiers:

• Use letters (A-Z, a-z), digits (0-9), or underscores (_).
• Start with a letter or underscore, not a number.
• Case matters: score and Score are different.
• Don’t use keywords as names—that’s a recipe for errors.

For instance, naming a variable playerScore makes it clear what it’s for, while x123 might leave you scratching your head later.

Constants: Fixed Values

Constants are values that don’t change once set. They’re like variables, but locked in place during the program’s run.

You can create constants in two ways:

• Using const: const int MAX_USERS = 100; sets a constant integer.
• Using #define: #define PI 3.14159 creates a constant via the preprocessor.

Constants are great for values like tax rates or physical constants that stay the same.

Variables: Storing Your Data

Variables are named spots in memory where you store data, like numbers or text. When you use a variable, you’re accessing or changing what’s in that memory spot.

Declare a variable like this:

[data_type] [variable_name];

Here’s an example with different types:

#include <iostream>
using namespace std;

int main() {

    string name = "The Wired Mind";   // String type variable
    int started_year = 2024;  // Integer type variable
    double pi = 3.14159;    // Double type variable
    char grade = 'A';       // Char type variable
    bool isActive = true;   // Bool type variable
    return 0;
}

This code shows how variables hold different kinds of data, making your program flexible.

Operators: Making Things Happen

Operators are symbols that perform actions, like adding numbers or comparing values. They’re the tools that bring your code to life.

Arithmetic Operators

For basic math:

Operator	What It Does
+	Adds
-	Subtracts
*	Multiplies
/	Divides
%	Finds remainder

Example: int sum = 5 + 3; sets sum to 8.

Increment and Decrement

For quick changes:

Operator	What It Does
++	Adds 1
--	Subtracts 1

Example: int count = 5; count++; makes count 6.

Relational Operators

For comparisons:

Operator	What It Checks
==	Equal to
!=	Not equal to
>	Greater than
<	Less than
>=	Greater or equal
<=	Less or equal

Example: if (score > 100) checks if score is over 100.

Logical Operators

For combining conditions:

Operator	What It Does
&&	True if both are true
!	Flips true to false (or vice versa)

Example: if (score > 50 && lives > 0) runs only if both conditions are true.

Bitwise Operators

For working with bits (binary):

Operator	What It Does
<<	Shifts bits left
>>	Shifts bits right
~	Flips all bits
&	Bitwise AND
^	Bitwise XOR

These are handy for low-level tasks like optimizing code.

Assignment Operators

For setting or updating values:

Operator	What It Does
=	Sets a value
+=	Adds and sets
-=	Subtracts and sets
*=	Multiplies and sets
/=	Divides and sets
%=	Remainder and sets
<<=	Shifts left and sets
>>=	Shifts right and sets
&=	AND and sets
^=	XOR and sets
	=

Example: x += 5; is shorthand for x = x + 5;.

Other Operators

For special tasks:

Operator	What It Does
,	Separates steps
sizeof()	Gets size of data
&	Gets memory address
*	Accesses pointer value
?:	Short if-then-else

Example: int max = (a > b) ? a : b; picks the larger of a or b.

Punctuation: Organizing Your Code

Punctuation symbols structure your code, keeping things in order.

Symbol	Purpose
;	Ends a statement
,	Separates items (like variables)
.	Accesses object members
->	Accesses pointer members
()	Groups expressions or calls functions
{}	Defines code blocks
[]	Accesses array elements

For example, ; ends a line like a period ends a sentence, and () calls a function like print().

Mastering tokens is like learning the alphabet of C++. Once you get them, you’re ready to build programs that do amazing things. Keep exploring with The Wired Mind for more coding insights!