A compound statement (also called a block, or block statement) is a group of zero or more statements that is treated by the compiler as if it were a single statement.
Blocks begin with a { symbol, end with a } symbol, with the statements to be executed being placed in between. Blocks can be used anywhere a single statement is allowed. No semicolon is needed at the end of a block.
You have already seen an example of blocks when writing functions, as the function body is a block:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
int add(int x, int y) { // start block return x + y; } // end block (no semicolon) int main() { // start block // multiple statements int value {}; // this is initialization, not a block add(3, 4); return 0; } // end block (no semicolon) |
Blocks inside other blocks
Although functions can’t be nested inside other functions, blocks can be nested inside other blocks:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
int add(int x, int y) { // block return x + y; } // end block int main() { // outer block // multiple statements int value {}; { // inner/nested block add(3, 4); } // end inner/nested block return 0; } // end outer block |
When blocks are nested, the enclosing block is typically called the outer block and the enclosed block is called the inner block or nested block.
Using blocks to execute multiple statements conditionally
One of the most common use cases for blocks is in conjunction with if statements. By default, an if statement executes a single statement if the condition evaluates to true. However, we can replace this single statement with a block of statements if we want multiple statements to execute when the condition evaluates to true.
For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include <iostream> int main() { // start of outer block std::cout << "Enter an integer: "; int value {}; std::cin >> value; if (value >= 0) { // start of nested block std::cout << value << " is a positive integer (or zero)\n"; std::cout << "Double this number is " << value * 2 << '\n'; } // end of nested block else { // start of another nested block std::cout << value << " is a negative integer\n"; std::cout << "The positive of this number is " << -value << '\n'; } // end of another nested block return 0; } // end of outer block |
If the user enters the number 3, this program prints:
Enter an integer: 3 3 is a positive integer (or zero) Double this number is 6
If the user enters the number -4, this program prints:
Enter an integer: -4 -4 is a negative integer The positive of this number is 4
We’ll talk more about if statements, including the use of blocks, in lesson 5.2 -- If statements.
Block nesting levels
It is even possible to put blocks inside of blocks inside of blocks:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
int main() { // nesting level 1 std::cout << "Enter an integer: "; int value {}; std::cin >> value; if (value > 0) { // nesting level 2 if ((value % 2) == 0) { // nesting level 3 std::cout << value << " is positive and even\n"; } else { // also nesting level 3 std::cout << value << " is positive and odd\n"; } } return 0; } |
The nesting level (also called the nesting depth) of a function is the maximum number of blocks you can be inside at any point in the function (including the outer block). In the above function, there are 4 blocks, but the nesting level is 3 since you can never be inside more than 3 blocks at any point.
It’s a good idea to keep your nesting level to 3 or less. Just as overly-long functions are good candidates for refactoring (breaking into smaller functions), overly-nested functions are also good candidates for refactoring (with the most-nested blocks becoming separate functions).
Best practice
Keep the nesting level of your functions to 3 or less. If your function has a need for more, consider refactoring.
 6.2 -- User-defined namespaces |
 Index |
 O.4 -- Converting between binary and decimal |
Can I use compound statements alone, outside any if, function, etc?
Eg:
Yes.
If you think you need to do this to make your code more tidy, use a function instead.
But doesn't it raise the concerns about scope of a variable as shown in one of the comments.(Copying the code from @Alireza's comment)
Eg:
int main()
{
int a = 0;
std::cout << a ;
{
int a = 1;
std::cout << a;
{
int a = 2;
std::cout << a;
}
}
std::cout << a;
return 0;
}
I don't understand what you're getting at. Alireza's code can be re-written with functions and without shadowing (see Alex's answer to Alireza's comment).
"It is even possible to put blocks inside of blocks inside of blocks:" can be changed to
"It is even possible to put blocks inside block:"
The subsequent example shows a 3-level nesting, which is actually a block inside a block inside a block.
Hi,
In the following program:
output:
0120
@a doesn't work similarly @a at the 2nd block and 3rd block. When should we use blocks like this way ?
the 2nd and 3rd nested blocks shadow the outer block a, so your code actually runs identically to this program:
> When should we use blocks like this way ?
Never. :) Just because you can do something doesn't mean you should.
Nice work
Hi!
In the third program , what result would we get if we enter a negative integer ? Who don’t we have an else statement for negative integers ? Also , isn’t it necessary that every if statement needs to be followed by an else statement ?
I think the reason is because as we have taken data type as int, which is already unsigned and accepts only positive integral values. But if we had already specified the data type earlier , why did we need an If statement for accepting only positive numbers? Even if we did not have an if statement for accepting positive integral values , and the user entered a negative number , wouldn’t we get an error in either case ?
Hi Aditi!
> what result would we get if we enter a negative integer
No output
> isn’t it necessary that every if statement needs to be followed by an else statement
No, you don't need an else-statement
> we have taken data type as int, which is already unsigned
An int is signed by default
Run the program yourself, play around with some numbers and place breakpoints to get a better understanding of what's happening.
@nascardriver okay thank you !
Hi Alex!
could you go through my code and correct the mistakes i made?
oh and please explain this piece:
tempNum = larger;
larger = smaller;
smaller = tempNum;
Hi Ali!
I've added comments addressing the issue with your code.
Try correcting it and post your progress, if you have any questions feel free to ask.
> please explain this piece
It's swapping the values of @larger and @smaller. Imagine you have three baskets in front of you, one contains a red apple, one contains a green apple and one is empty.
You want the red apple to be in the green apple's basket and the green apple to be in the red apple's basket.
You are only allowed to hold one apple at a time.
PS: Please post your code in the corresponding lesson next time, this quiz is in lesson 4.1a
isn't that some kind of sorting?
No it's not, you only want two elements to change places.
EDIT: Well, technically, it might be sorting since you now have two elements in a specific order, but I would call it sorting when it's just two elements and not even a list/array.
i remember the bubble sorting used a method like this. or at least some kind of like this
Yes, many sorting methods work by swapping elements until the list of items is sorted. Bubble sort swaps adjacent elements. Selection sort swaps once per iteration.
Generally, when we transpose the value of two elements, we call it a swap. We call it a sort when we put all the elements in a list or array into some sorted order.
Hi Alex, how many tutorials do you recommeend me on reading daily?
I don't have a recommendation on this.
It really depends entirely on your learning capability, motivation, and how much time you want to spend experimenting with each topic on your own.
i have the time to read as much as i want and my learning capability is pretty big i guess. with each topic i guess 20 minutes-1 hour or 1,5 hour depending if it has coding quizzes in it. so how much should i read? oh and i lack motivation i guess so how should i motivate myself? for example i start watching videos, news while im supposed to learn.
> in the ifElse function there's no need to return tempNum you can return larger either. And Its good to initialize tempNum directly above where you do swapping.
> ifElse returns something and you are not storing it. If you don't want to, change the functions type to void.
Hi Alex. The Output of the first program has a mistake!
This is the code :
below it we have this output :
Enter an integer: 3
3 is a positive integer
Double this number is 6
I guess it should be like this :
Enter an integer: 3
3 is a positive integer (or zero)
Double this number is 6
Thank You! : ))
Thanks, fixed!
Thank you so much for making all these.
On the 2ed code example if you put in 0 won't it fail when it gets to
No, why would it? 0 * 2 = 0.
Oh I see now it is division by zero.
Alex thank you so much your time, you help many people. Are you familiar with socket programming in C++?
Best regards,
Jack
I've used sockets in the distant past but I've probably forgotten more than I know about them. :(
Thats what happened to me not with sockets but core C++ :( thats why I am revising all the updated lessons.
Hey Alex,
maybe you should add a special case for 0 on your second program, now it says that 0 is a negative integer.
Good catch. I updated the conditional on the first if statement to handle this properly.
Alex,
On line 18 of the second program you have:
cout << "The positive of this number is " << -value << endl;.
Since you entered -4 for the input, how does the program know to print out 4 (positive)? when no math is ever done?
Does this somehow say take value and multiply it times -1 ?
In math we learned (-4 * -1)= 4.
-4 * -1 = 4
and -(-4) also equals 4 the program uses second math.
In the last code example above, you're missing a semi-colon at the end of the line(4):
Thanks, fixed!
A minor note in the last program
it should be just value instead of nValue shouldn't it?
In block inside of block inside of block!
:-)
Yep, fixed. Thanks for pointing that out.
Typo.
I would change the title,
"4.1 — Blocks (compound statements) and local variables"
to the title referenced on your main page
"4.1 — Blocks (compound statements)"
since you don't talk about local variables here.
Good call. I used to talk about local variables here, but moved it into section 1.
Blockception.
best comment so far!!! lol
Great!
The best tutorials I've ever seen :P
It may be helpful to point out that since a block replaces a single statement (that ends with a semicolon), the block supercedes the use of a semicolon. No semicolon is necessary to end a block.
Now i see a benefit from declare_variable_when_needed instead of all at the top of the function.
Cheers :)
Hi Alex,
Fabulous work, first of all.
I have a question: how does "using namespace std" work with the nesting? It seems that once written in a block, it is valid for the sub-blocks as well. If it is so, wouldn't it be easier to simply declare it at the beginning rather than several times inside functions?
Thanks.
As you note, using statements also use normal scoping rules -- if used inside a block, it applies to the block and all subblocks.
Hey Alex when you read this would like to suggest adding something like a review at the end of every section just quickly reminding people like for example on the variables section 1 it would say all the variable types with quick meanings and examples maybe.