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 prohibits 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 MyInt objects be created. This can prevent some unexpected type conversions and improve code readability and safety.

It should be noted 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, which simplifies 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. Because auto only performs type deduction at compile-time and does not increase 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 contributes to improved code clarity and maintainability.