Types of Comments in C++
In C++, there are two main types of comments:
1. Single-line comments
2. Multi-line comments
Single-line comments start with two forward slashes (`//`). Anything after the `//` on the same line is considered a comment & is ignored by the compiler. Here's an example:
// This is a single-line comment
int x = 5; // This is also a single-line comment
Multi-line comments, also known as block comments, start with `/*` & end with `*/`. Anything between these two markers, even if it spans multiple lines, is considered a comment.
For example :
/* This is a
multi-line comment.
It can span multiple lines. */
int y = 10;
You can also use multi-line comments for a single line:
/* This is a single-line comment using the multi-line style */
Note: Both types of comments are useful in different situations. Single-line comments are usually used for brief explanations or notes, while multi-line comments are used for longer explanations or for temporarily disabling large blocks of code.
How the Compilers Process Comments in C++
When you write a C++ program, the code you write is first processed by a compiler before it's turned into an executable program. The compiler's job is to translate your C++ code into machine code that the computer can understand & execute.
However, the compiler treats comments differently than the rest of your code. When the compiler encounters a comment, it simply ignores it & moves on to the next part of the code. This is why comments don't affect the way your program runs.
For example :
C++
#include <iostream>
int main() {
// This is a comment
std::cout << "Hello, World!" << std::endl; // This prints "Hello, World!"
return 0;
}
You can also try this code with Online C++ Compiler
Output
"Hello, World!"
When the compiler processes this code, it effectively sees it like this:
C++
#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}
You can also try this code with Online C++ Compiler
Output
"Hello, World!"
The comments are completely removed by the compiler, leaving only the actual C++ code. This is why you can put comments almost anywhere in your code without affecting its functionality.
However, it's important to note that while comments are ignored by the compiler, they are still a part of your source code. This means that they can take up space in your source files, & they will be visible to anyone who looks at your code.
C-style Comments
C-style comments, also known as multi-line comments, are a type of comment that was inherited from the C programming language. They start with `/*` and end with `*/`, and anything in between these markers is considered a comment.
For example :
/* This is a C-style comment.
It can span multiple lines.
And it can contain any characters, including special characters like *&$#@. */
C-style comments have a few characteristics:
1. They can span multiple lines.
2. They can be placed anywhere in the code - on their own line, at the end of a line of code, or even in the middle of a line of code.
3. They can contain any characters, including other comment markers.
However, C-style comments cannot be nested. This means you can't have a comment inside another comment. For example:
/* This is a comment /* with another comment inside */ */
This will not work as intended. The compiler will treat everything from the first `/*` to the first `*/` as a comment, and then it will encounter the unexpected `*/` after the second comment.
Note: Despite this limitation, C-style comments are still widely used, especially for larger, multi-line comments or for temporarily disabling large blocks of code during debugging.
C++ style Comments
C++ introduced its own style of comments, known as single-line comments or C++ style comments. These start with two forward slashes (`//`) and continue until the end of the line.
For example :
// This is a C++ style comment
int x = 5; // This is another C++ style comment
C++ style comments have a few characteristics:
1. They only extend to the end of the line. Anything after the `//` on the same line is part of the comment, but anything on the next line is not.
2. They can be placed anywhere on a line - at the start, middle, or end.
3. They are often used for short, one-line explanations or notes.
One advantage of C++ style comments is that they make it easy to comment out a single line of code:
int x = 5;
// int y = 10;
int z = x + y;
In this example, the second line is commented out, so the compiler will ignore it. This can be useful when debugging or when you want to temporarily disable a line of code.
Note: C++ style comments are generally used for brief, single-line comments because they are more concise and easier to read than C-style comments. However, both types of comments have their uses, and you'll often see both in C++ code.
/* and */ Comments
As we've seen, C-style comments (also known as multi-line comments) start with /* and end with */. Let’s see a few more things to know about using this type of comment:
1. Anything between /* and */ is part of the comment, even if it spans multiple lines:
/* This comment
spans multiple
lines */
2. You can put /* and */ comments almost anywhere in your code:
/* This is a standalone comment */
int x = 5; /* This comment comes after a line of code */
int /* this comment is in the middle of a line of code */ y = 10;
3. Be careful not to accidentally nest /* and */ comments. The compiler will only recognize the first /* and the first */ it sees:
/* This is a comment /* with another comment inside */ this part will not be a comment */
4. It's a good practice to use /* and */ comments for multi-line explanations or for temporarily disabling large blocks of code:
/* This function calculates the average of two numbers
by adding them together and dividing by 2. */
double average(double a, double b) {
return (a + b) / 2;
}
While // comments are more commonly used for short, single-line comments in modern C++ code, /* and */ comments are still widely used and are an important part of the C++ language.
Frequently Asked Questions
Can comments be used to prevent a line of code from being executed?
Yes, you can use comments to temporarily disable a line or block of code. This is called "commenting out" the code.
Do comments affect the performance of the program?
No, comments are completely ignored by the compiler, so they don't affect the program's performance at all.
Is there a preferred style of commenting in C++?
It's largely a matter of personal preference or team convention. Many developers prefer C++ style (//) comments for short, single-line comments and C-style (/* */) comments for longer, multi-line comments. The most important thing is to be consistent in your use of comments.
Conclusion
In this article, we have learned about comments in C++. We explained what comments are, why they are used, and the different types of comments available in C++. We also saw how the compiler handles comments and some best practices for using comments in your code.
You can also check out our other blogs on Code360.
38+ registered 
