Multiplication

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

1. Pointer Declaration (Type Modifier)

// Syntax
T* declarator;
T * declarator;
T *declarator;

• Binding: In C++ grammar, the * token is a ptr-operator that forms part of the declarator. It modifies the individual declarator it belongs to (specifically the unqualified-id or variable name), rather than the shared base type specifier. In the declaration int* a, b;, a is of type int* (pointer to int), while b is of type int.
• CV-Qualifiers: The * can be followed by const or volatile qualifiers to modify the pointer itself, rather than the pointed-to type (e.g., T* const declares a constant pointer to a mutable T).
• Multiple Indirection: Multiple * tokens can be chained to declare pointers to pointers (e.g., T**).

​

2. Pointer-to-Member Declaration (Type Modifier)

// Syntax
T ClassName::* declarator;

• Representation: A pointer-to-member does not hold a direct memory address; rather, it holds an offset or an internal representation that identifies a specific member within any instance of ClassName.
• Access: Dereferencing a pointer-to-member requires an object instance and is performed using the distinct .* or ->* operators, not the unary * operator.

​

3. Unary Indirection Operator (Dereference)

// Syntax
*expression

• Operand Requirements: The operand must be an expression of a pointer type (pointer to object or pointer to function).
• Return Category: The result is an lvalue expression of the pointed-to type. If the operand points to an object of a non-const type, the resulting lvalue is modifiable and can be assigned to. If the operand points to a function, the result is a function lvalue, which is not a modifiable lvalue and cannot be assigned to, regardless of const qualification.
• Undefined Behavior (UB) and Exceptions: Evaluating the indirection operator on an uninitialized pointer, a dangling pointer, or a null pointer invokes undefined behavior. There is exactly one exception: if the operand is a null pointer to a polymorphic type and is evaluated within a typeid expression (e.g., typeid(*p)), the runtime safely throws a std::bad_typeid exception. If the pointer is uninitialized or dangling, evaluating typeid(*p) remains undefined behavior, as the program attempts to read an invalid memory address to access the object’s vtable.
• Overloading: The unary * operator can be overloaded for user-defined types (e.g., smart pointers, iterators). While it conventionally returns an lvalue reference (T&), the language permits the overload to return by value, which is frequently utilized to return proxy objects in custom iterators.

​

4. Binary Multiplication Operator

// Syntax
expression1 * expression2

• Operand Requirements: Both operands must be of arithmetic types (integral or floating-point) or unscoped enumeration types.
• Type Conversion: The operands are subject to standard arithmetic conversions and integral promotions before the operation is performed. The type of the result is the common type determined by these conversions.
• Overflow: If the result exceeds the representable range of the computed type, signed integer overflow results in undefined behavior, whereas unsigned integer overflow wraps around modulo 2ⁿ.
• Overloading: The binary * operator can be overloaded for user-defined types by defining a non-member function T operator*(const L& lhs, const R& rhs) or a member function T operator*(const R& rhs) const.

​

5. Lambda Capture-by-Copy Specifier

// Syntax
[*this]() { /* ... */ }

• Capture Semantics: Introduced in C++17, the * token modifies the capture behavior of the enclosing object. Instead of capturing the this pointer by value, *this instructs the compiler to capture the entire enclosing object by value, copying its state directly into the lambda’s generated closure type.
• Immutability: By default, the copied object within the closure is const. Modifying its members from within the lambda body requires the lambda to be declared mutable.