C++ چیٹ شیٹ

تمام ڈیولپر ٹولز

مفت

قابل تلاش، قابل پرنٹ جدید C++ حوالہ: سمارٹ پوائنٹرز، کنٹینرز، الگورتھمز، RAII، موو سیمینٹکس، ٹیمپلیٹس اور کنکرنسی۔ مفت۔

Basics, auto & references

auto x = 42;

Type deduction (int here)

const auto& r = bigObject;

Cheap read-only reference

int& ref = x; ref = 5;

Reference: alias to a variable

constexpr int N = 10;

Compile-time constant

using Ids = std::vector<int>;

Type alias (modern typedef)

auto [key, value] = *map.begin();

Structured bindings (C++17)

if (auto it = m.find(k); it != m.end())

Init-statement inside if (C++17)

enum class Color { Red, Green };

Scoped enum (no implicit int)

nullptr

Typed null pointer (never NULL)

static_cast<int>(3.99)

Explicit checked-style cast

std::int64_t n = 0; // <cstdint>

Fixed-width integer types

Smart pointers

auto p = std::make_unique<Widget>(args);

Sole owner, freed on scope exit

auto s = std::make_shared<Widget>();

Ref-counted shared ownership

std::unique_ptr<Widget> q = std::move(p);

Transfer ownership (no copy)

std::weak_ptr<Widget> w = s;

Non-owning observer of shared

if (auto sp = w.lock()) sp->run();

Safely promote weak → shared

p.get()

Raw pointer view (no ownership)

p.reset();

Destroy the owned object early

s.use_count()

Current shared reference count

void observe(const Widget& w);

Pass & or * to non-owners

std::unique_ptr<T[]> a = std::make_unique<T[]>(n);

Owned dynamic array

Containers

std::vector<int> v{1, 2, 3};

Dynamic array (default choice)

v.push_back(4); v.emplace_back(args);

Append (emplace constructs)

v.reserve(1000);

Pre-allocate to avoid regrowth

std::map<std::string, int> m;

Sorted key→value tree

std::unordered_map<std::string, int> h;

Hash map (faster, unsorted)

m["hits"] += 1; m.at("hits");

[] inserts default; at() throws

if (m.contains(key)) ...

Membership test (C++20)

std::array<int, 3> a{1, 2, 3};

Fixed-size stack array

void f(std::span<const int> s);

Non-owning view of any array

std::set<int> s; std::unordered_set<int> u;

Unique-element containers

std::erase_if(v, [](int n) { return n < 0; });

Erase-remove in one call (C++20)

v.size(); v.empty(); v.clear();

Common capacity operations

Algorithms & ranges

std::ranges::sort(v);

Sort a whole container (C++20)

std::sort(v.begin(), v.end(), cmp);

Classic iterator-pair sort

auto it = std::ranges::find_if(v, pred);

First element matching pred

std::transform(v.begin(), v.end(), out, f);

Map each element into out

std::accumulate(v.begin(), v.end(), 0)

Sum / fold (<numeric>)

std::ranges::count_if(v, pred)

Count matching elements

v | std::views::filter(isEven)

Lazy filtered view (C++20)

| std::views::transform(square)

Chain lazy transformations

std::views::iota(0, 10)

Lazy range of ints 0..9

auto v2 = r | std::ranges::to<std::vector>();

Materialize a view (C++23)

std::ranges::max_element(v)

Iterator to the largest value

std::ranges::any_of(v, pred)

any_of / all_of / none_of

Strings & string_view

std::string s = "hi"; s += "!";

Owning, growable string

void f(std::string_view sv);

Non-owning read-only view

if (s.find("x") != std::string::npos)

Substring search

s.substr(1, 3)

Slice (pos, length)

s.starts_with("http"); s.ends_with(".h");

Prefix / suffix tests (C++20)

s.contains("needle")

Substring test (C++23)

std::to_string(42)

Number → string

int n = std::stoi("42");

String → int (stod, stol...)

std::format("{}: {}", key, count)

Type-safe formatting (C++20)

std::getline(std::cin, line);

Read a whole input line

R"(C:\path\no "escapes")"

Raw string literal

Classes & RAII

struct Point { int x = 0; int y = 0; };

struct: public by default

Widget() : size_{0}, name_{"w"} {}

Member initializer list

~Widget() { close(handle_); }

Destructor releases resources

ctor, dtor, copy ctor/=, move ctor/=

Rule of five (define all or none)

Widget(const Widget&) = delete;

Forbid copying

Widget(Widget&&) noexcept = default;

Opt into generated move

explicit Widget(int size);

Block implicit conversions

int size() const { return size_; }

const member: no mutation

virtual void draw(); / void draw() override;

Polymorphism + override check

virtual ~Base() = default;

Virtual dtor for base classes

[[nodiscard]] bool ok() const;

Warn when return is ignored

Move semantics

auto b = std::move(a);

Cast to rvalue: steal resources

Widget(Widget&& o) noexcept;

Move constructor signature

return result;

Return by value: NRVO or move

void set(std::string s) { s_ = std::move(s); }

Sink param: by value + move

v.push_back(std::move(str));

Move into a container

auto old = std::exchange(ptr_, nullptr);

Take value, reset the source

std::swap(a, b);

Exchange two values cheaply

// moved-from: valid but unspecified

Only assign/destroy after move

template <class T> void f(T&& x) { g(std::forward<T>(x)); }

Perfect forwarding

Templates & concepts

template <typename T> T maxOf(T a, T b);

Function template

template <std::integral T> T half(T n);

Constrain with a concept (C++20)

template <class T> concept Number = std::is_arithmetic_v<T>;

Define a custom concept

void print(const auto& x);

Abbreviated template (C++20)

if constexpr (std::is_integral_v<T>)

Compile-time branch

std::pair p{1, 2.5};

CTAD: deduce class template args

template <typename... Args> void log(Args&&... args);

Variadic template

(args + ...)

Fold expression over a pack

template <class T> requires Number<T> T sq(T x);

requires clause

template <> struct Hash<Key> { ... };

Explicit specialization

Lambdas & std::function

auto twice = [](int x) { return x * 2; };

Basic lambda

[=] captures copies; [&] captures refs

Default capture modes

[x, &total](int n) { total += x * n; }

Mixed explicit captures

[this] { return counter_; }

Capture the enclosing object

[p = std::move(ptr)] { p->run(); }

Init-capture (move into lambda)

[n = 0]() mutable { return ++n; }

mutable: modify captured copies

[](auto a, auto b) { return a < b; }

Generic lambda

[](int x) -> double { return x / 2.0; }

Explicit return type

std::function<int(int)> cb = twice;

Type-erased callable holder

std::ranges::sort(v, {}, &User::age);

Projection instead of a lambda

Error handling

std::optional<int> parse(std::string_view s);

Maybe-a-value return type

opt.value_or(0)

Unwrap with a fallback

if (opt) use(*opt);

Test then dereference

std::expected<Data, Error> load();

Value-or-error return (C++23)

res.and_then(step).transform(format)

Monadic chaining (C++23)

throw std::runtime_error("bad config");

Throw a standard exception

catch (const std::exception& e) { e.what(); }

Catch by const reference

void close() noexcept;

Promise not to throw

assert(ptr != nullptr);

Debug-only invariant check

static_assert(sizeof(int) == 4);

Compile-time assertion

std::variant<int, Err> v; std::visit(fn, v);

Closed sum type + visitor

Concurrency

std::jthread t(work);

Auto-joining thread (C++20)

std::thread t(work); t.join();

Classic thread (must join)

std::mutex m; std::lock_guard lock(m);

Scoped lock (RAII)

std::scoped_lock lock(m1, m2);

Lock several without deadlock

std::unique_lock lk(m); cv.wait(lk, ready);

Condition variable wait

std::atomic<int> hits{0}; ++hits;

Lock-free counter

auto f = std::async(std::launch::async, fetch);

Run async, get a future

auto result = f.get();

Block until the result is ready

std::this_thread::sleep_for(100ms);

Sleep (std::chrono_literals)

thread_local int cache = 0;

One instance per thread

Compilation & CMake

g++ -std=c++23 -Wall -Wextra -O2 main.cpp -o app

Typical release compile

clang++ -std=c++20 main.cpp -o app

Same flags work with clang

-g -O0

Debug build (symbols, no opt)

-fsanitize=address,undefined

Catch memory/UB bugs at runtime

-Iinclude -Llib -lfoo

Header path, lib path, link lib

-DNDEBUG

Strip assert() in release

cmake_minimum_required(VERSION 3.20)

CMakeLists.txt first line

add_executable(app main.cpp)

Declare the binary target

target_compile_features(app PRIVATE cxx_std_23)

Require a C++ standard

cmake -B build && cmake --build build

Configure then build

cmake --build build -j 8

Parallel build

کوئی اندراج “:q” سے میل نہیں کھاتا۔

C++ چیٹ شیٹ کے بارے میں

یہ C++ چیٹ شیٹ جدید C++ کو ایک قابل تلاش حوالے میں جمع کرتی ہے: auto اور ریفرنسز کے ساتھ بنیادی باتیں، سمارٹ پوائنٹرز، کنٹینرز، الگورتھمز اور رینجز، سٹرنگز اور string_view، کلاسز اور RAII، موو سیمینٹکس، ٹیمپلیٹس اور کنسیپٹس، لیمبڈاز اور std::function، خرابیوں کی ہینڈلنگ، کنکرنسی، اور CMake کے ساتھ کمپائلیشن۔

It is aimed at the C++ people actually write today: unique_ptr and shared_ptr instead of raw new and delete, range-based algorithms, structured bindings, concepts on templates, std::thread and std::mutex; while still spelling out the fundamentals like the rule of five and RAII.

اس گروپ کی ہر چیٹ شیٹ کی طرح یہ مفت اور کلائنٹ سائیڈ ہے: سرچ باکس سے قطاروں کو لائیو فلٹر کریں، چپکے رہنے والی فہرست مضامین سے حصوں کے درمیان کودیں، ایک کلک سے کوئی بھی اسنیپٹ کاپی کریں اور میز کے حوالے کے طور پر صفحہ پرنٹ کریں۔

C++ چیٹ شیٹ استعمال کرنے کا طریقہ

شیٹ کھولیں اور حصوں کا جائزہ لیں، Basics, auto & references سے لے کر Compilation & CMake تک۔
unique_ptr، ranges یا concept جیسا کوئی کلیدی لفظ تلاش کریں تاکہ شیٹ لائیو فلٹر ہو جائے۔
جب آپ کو مشکل سنٹیکس کی وضاحت چاہیے ہو تو Move semantics یا Templates & concepts پر جائیں۔
C++ کوڈ کو اپنی کلپ بورڈ پر کاپی کرنے کے لیے کسی اسنیپٹ یا اس کے کاپی آئیکن پر کلک کریں۔
مکمل C++ حوالے کی کاغذی کاپی کے لیے Print استعمال کریں۔

اکثر پوچھے جانے والے سوالات

بارہ حصے: auto اور ریفرنسز کے ساتھ بنیادی باتیں، سمارٹ پوائنٹرز، کنٹینرز، الگورتھمز اور رینجز، سٹرنگز اور string_view، کلاسز اور RAII، موو سیمینٹکس، ٹیمپلیٹس اور کنسیپٹس، لیمبڈاز اور std::function، خرابیوں کی ہینڈلنگ، کنکرنسی، اور CMake کے ساتھ کمپائلیشن۔

جدید۔ یہ دستی میموری مینجمنٹ کے بجائے سمارٹ پوائنٹرز، RAII، موو سیمینٹکس، سٹرکچرڈ بائنڈنگز، رینجز اور کنسیپٹس سے شروع ہوتی ہے۔

جی ہاں۔ کنٹینرز اور الگورتھمز کے حصے vector، map، unordered_map، set، deque اور عام الگورتھمز (sort، find، transform، accumulate) کو ان کی رینج پر مبنی شکلوں کے ساتھ درج کرتے ہیں۔

جی ہاں۔ کسی بھی قطار کے کوڈ یا اس کے کاپی آئیکن پر کلک کریں اور وہ فوراً کاپی ہو جاتا ہے۔

جی ہاں، یہ مکمل طور پر مفت ہے اور بغیر لاگ ان کے آپ کے براؤزر میں چلتا ہے۔

C++ چیٹ شیٹ

Basics, auto & references

Smart pointers

Containers

Algorithms & ranges

Strings & string_view

Classes & RAII

Move semantics

Templates & concepts

Lambdas & std::function

Error handling

Concurrency

Compilation & CMake

C++ چیٹ شیٹ کے بارے میں

C++ چیٹ شیٹ استعمال کرنے کا طریقہ

اکثر پوچھے جانے والے سوالات

C++ چیٹ شیٹ میں کیا کیا شامل ہے؟

کیا یہ جدید C++ ہے یا پرانے انداز کا C++؟

کیا یہ STL میں مدد کرتی ہے؟

کیا میں ایک کلک سے اسنیپٹ کاپی کر سکتا ہوں؟

کیا C++ حوالہ مفت ہے؟

متعلقہ ٹولز

مقبول تلاشیں

یہ ٹول ایمبیڈ کریں