The unary prefix operator &, when applied to an object, yields the address of the object: &obj. The type modifier &, when applied to a variable about to be declared, will modify the variable’s type to be a reference type: int&. The same applies to *: When applied as a unary prefix operator to a … Read more
Yes, removing a Foo* from a container destroys the Foo*, but it will not release the Foo. Destroying a raw pointer is always a no-op. It cannot be any other way! Let me give you several reasons why. Storage class Deleting a pointer only makes sense if the pointee was actually allocated dynamically, but how … Read more
Consider the following programs: Sample 1: #include<stdio.h> int main() { printf(“Hello World”); return 0; } Sample 2: #include<cstdio> int main() { printf(“Hello World”); return 0; } Both work as expected. So which usage is more appropriate? The answer is: Neither! Surprised? Read on. The C++ Standard library provides all standard C headers for compatibility reason, … Read more
Your compiler just tried to compile the file named foo.cc. Upon hitting line number line, the compiler finds: #include “bar” or #include <bar> The compiler then tries to find that file. For this, it uses a set of directories to look into, but within this set, there is no file bar. For an explanation of … Read more
This is called the three-way comparison operator. According to the P0515 paper proposal: There’s a new three-way comparison operator, <=>. The expression a <=> b returns an object that compares <0 if a < b, compares >0 if a > b, and compares ==0 if a and b are equal/equivalent. To write all comparisons for … Read more
One may try to replace new and delete operators for a number of reasons, namely: To Detect Usage Errors: There are a number of ways in which incorrect usage of new and delete may lead to the dreaded beasts of Undefined Behavior & Memory leaks. Respective examples of each are: Using more than one delete … Read more
When you write = {0}, that only explicitly initialises the first member; the rest are zero-initialised implicitly according to the standard, so it appears at first glance that you explicitly initialised all members with the 0 that you wrote, but you didn’t. That place where you wrote 0 only affects the first member. So when, … Read more
A pointer can be re-assigned: int x = 5; int y = 6; int *p; p = &x; p = &y; *p = 10; assert(x == 5); assert(y == 10); A reference cannot be re-bound, and must be bound at initialization: int x = 5; int y = 6; int &q; // error int &r … Read more
That’s indeed the idea. The point is that you are explicit about what you mean, so that an otherwise silent error can be diagnosed: struct Base { virtual int foo() const; }; struct Derived : Base { virtual int foo() // whoops! { // … } }; The above code compiles, but is not what … Read more
There are three flags that indicate error state: badbit means something has gone very wrong with the stream. It might be a buffer error or an error in whatever is feeding data to the stream. If this flag is set, it’s likely that you aren’t going to be using the stream anymore. failbit means that … Read more