C Plus Plus Study Cards

Enhance Your Understanding with C++ Programming Concept Cards for quick learning



C++

A general-purpose programming language that supports procedural, object-oriented, and generic programming.

Variable

A named storage location in memory used to hold a value that can be modified during program execution.

Data Type

A classification of data that determines the possible values it can hold and the operations that can be performed on it.

Operator

A symbol that represents a specific action to be performed on one or more operands to produce a result.

If Statement

A control structure that executes a block of code if a specified condition is true.

For Loop

A control structure that repeatedly executes a block of code for a specified number of times.

Function

A named block of code that performs a specific task and can be called from other parts of the program.

Array

A collection of elements of the same data type, stored in contiguous memory locations.

Pointer

A variable that stores the memory address of another variable.

Class

A blueprint for creating objects that defines its properties and behaviors.

Inheritance

A mechanism that allows a class to inherit properties and behaviors from another class.

File Handling

The process of reading from or writing to files on a computer's file system.

Exception Handling

A mechanism to handle runtime errors and prevent program termination.

Template

A generic programming feature that allows the creation of functions and classes that can work with different data types.

STL

The Standard Template Library, a collection of template classes and functions for common data structures and algorithms.

Memory Allocation

The process of reserving and managing memory for storing data during program execution.

Constructor

A special member function that is automatically called when an object of a class is created.

Destructor

A special member function that is automatically called when an object of a class is destroyed.

Namespace

A declarative region that provides a scope for the identifiers within it, preventing naming conflicts.

Header File

A file that contains declarations and definitions of functions and variables to be used in other source files.

Preprocessor Directive

A statement that instructs the preprocessor to perform specific actions before the compilation process.

Virtual Function

A member function of a base class that can be overridden by a derived class to provide a different implementation.

Dynamic Memory Allocation

The process of allocating memory at runtime using the 'new' operator and deallocating it using the 'delete' operator.

Exception

An abnormal condition or error that occurs during program execution and disrupts the normal flow of control.

Polymorphism

The ability of an object to take on many forms, allowing objects of different classes to be treated as objects of a common base class.

Overloading

The ability to define multiple functions with the same name but different parameters, allowing different behaviors based on the arguments passed.

Template Specialization

A mechanism that allows the creation of specialized versions of template functions or classes for specific data types.

Iterator

An object that allows traversal of elements in a container, providing a way to access and manipulate the elements.

Lambda Expression

A concise way to define anonymous functions in C++, often used for inline function definitions or as arguments to higher-order functions.

Recursion

A programming technique where a function calls itself to solve a problem by breaking it down into smaller subproblems.

Static Variable

A variable that retains its value between function calls and is initialized only once.

Friend Function

A function that is not a member of a class but has access to its private and protected members.

Operator Overloading

The ability to redefine the behavior of an operator for user-defined types.

Smart Pointer

A class that wraps a raw pointer and provides automatic memory management, preventing memory leaks.

Exception Safety

The guarantee that a program will not leak resources or exhibit undefined behavior in the presence of exceptions.

Thread

A sequence of instructions that can be executed independently of other threads, allowing concurrent execution of tasks.

Mutex

A synchronization primitive used to protect shared resources from concurrent access by multiple threads.

Lambda Capture

The mechanism that allows lambda expressions to access variables from their surrounding scope.

Move Semantics

A feature that allows the efficient transfer of resources from one object to another, avoiding unnecessary copying.

RAII

Resource Acquisition Is Initialization, a programming technique that associates the lifetime of a resource with the lifetime of an object.

Concurrency

The ability of a program to execute multiple tasks simultaneously, improving performance and responsiveness.

Lambda Closure

The combination of a lambda expression and the variables it captures, allowing the lambda to access and modify those variables.

Template Metaprogramming

A technique that uses templates to perform computations and generate code at compile-time.

Standard Library

A collection of pre-defined classes and functions provided by the C++ Standard Library for common programming tasks.

Concurrency Control

The management of simultaneous access to shared resources in a multi-threaded environment to prevent data races and ensure consistency.