Petty C++ - Keywords

explicit#

Used to modify the constructor of a class. Its purpose is to prevent implicit type conversions and only allow explicit calls to the constructor for object initialization.

When a constructor is declared as explicit, it prevents the compiler from performing implicit type conversions to call that constructor. This means that objects can only be created by explicitly calling the constructor and not by using implicit type conversions.

Here is an example using the explicit keyword:

auto#

class MyInt {
public:
    explicit MyInt(int value) : num(value) {}
    int getValue() const { return num; }
private:
    int num;
};

void printValue(const MyInt& obj) {
    cout << obj.getValue() << endl;
}

int main() {
    MyInt obj1 = 10;  // Error, implicit type conversion is prohibited
    MyInt obj2(20);  // Correct, explicit call to the constructor
    printValue(obj2);  // Correct, passing object as parameter
    printValue(30);  // Error, implicit type conversion is prohibited
    return 0;
}

In the above example, the constructor of the MyInt class is declared as explicit, thus prohibiting implicit type conversions. Only by explicitly calling the constructor can a MyInt object be created. This helps to avoid unexpected type conversions and improves code readability and safety.

It is important to note that the explicit keyword can only be used for single-parameter constructors and does not apply to default constructors or constructors with multiple parameters.

auto x = 5;
auto y = 3.14;

std::vector<int> v = {1,2,3};
auto it = v.begin(); // it is deduced as std::vector<int>::iterator

auto is also commonly used in range-based for loops, simplifying iterator syntax.

Implementation#

The auto keyword in C++11 is a type deduction mechanism. When defining a variable using auto, the compiler checks the initialization expression of the variable during compilation and deduces a specific type. This process is done entirely at compile-time and does not involve runtime type checking or conversion.

Use Cases#

The auto keyword is mainly used in several scenarios:

Simplifying the declaration of complex types: When dealing with complex types, especially iterators of STL containers, auto can simplify the code.

std::map<std::string, std::vector<int>> complexMap;
for(auto it = complexMap.begin(); it!= complexMap.end(); ++it){
  // do someting
}

Used in generic programming: In template programming, when the type depends on template parameters, using auto can simplify the code and increase flexibility.
Automatic type deduction: In some complex expressions, especially those involving lambda expressions or other cases where the type can only be determined at runtime, auto can handle type deduction automatically.

Impact on Performance#

Using auto does not have a direct impact on performance. Since auto only performs type deduction at compile-time, it does not add any runtime overhead. In fact, it can help avoid some common errors, such as performance issues caused by implicit type conversions.

However, excessive use of auto may decrease code readability, especially when the deduced type is not obvious. Therefore, it is recommended to use auto in cases where the type is clear and it helps improve code clarity and maintainability.