Avoiding C++ Copy Constructor Infinite Recursion

Day 177/365 – DSA Challenge 📘 Solved Distinct Subsequences on LeetCode today. 🔹 Problem: Count the number of distinct subsequences of string s that equal string t. 🔹 Approach Used: Dynamic Programming (2D DP) Steps followed: 1️⃣ Let dp[i][j] = number of ways to form t[j:] from s[i:] 2️⃣ Base case: dp[i][n] = 1 (empty string can always be formed) 3️⃣ Traverse from back: If characters match → include + exclude Else → skip character in s 🔹 Transition: If s[i] == t[j] → dp[i][j] = dp[i+1][j+1] + dp[i+1][j] Else → dp[i][j] = dp[i+1][j] 🔹 Key Idea: At each step → either use the character or skip it 🔹 Time Complexity: O(m × n) 🔹 Space Complexity: O(m × n) 💻 Language: C++ Classic DP problem that builds strong intuition for subsequence counting patterns 🔥 #Day177 #365DaysOfCode #DSA #LeetCode #DynamicProgramming #Strings #Cpp

🚫 Stop passing 𝒄𝒐𝒏𝒔𝒕 𝒔𝒕𝒅::𝒔𝒕𝒓𝒊𝒏𝒈& when you don't need to. There's a better way, and it's been in C++17 since 2017. Meet 𝒔𝒕𝒅::𝒔𝒕𝒓𝒊𝒏𝒈_𝒗𝒊𝒆𝒘. Here's a classic mistake I see in C++ codebases. When you pass "hello" to a 𝒄𝒐𝒏𝒔𝒕 𝒔𝒕𝒅::𝒔𝒕𝒓𝒊𝒏𝒈&, the runtime silently allocates a new 𝒔𝒕𝒅::𝒔𝒕𝒓𝒊𝒏𝒈. With 𝒔𝒕𝒓𝒊𝒏𝒈_𝒗𝒊𝒆𝒘? Nothing. Zero overhead. It's just a pointer + length pair pointing to an existing buffer. Where it really shines is substring parsing, no new, no heap, no copy. You're just sliding a window over existing memory. 🧠 Key insight: 𝒔𝒕𝒓𝒊𝒏𝒈_𝒗𝒊𝒆𝒘 is perfect for read-only string processing parsers, tokenizers, log analyzers, and protocol handlers. Anywhere you're slicing and inspecting strings without modifying them. Two caveats worth knowing: · Don't store a 𝒔𝒕𝒓𝒊𝒏𝒈_𝒗𝒊𝒆𝒘 if the underlying string can be destroyed, dangling reference territory. · It's non-owning by design. That's the whole point. Available since C++17. If you're not using it, you're leaving free performance on the table. This is Day 1 of my C++ deep-dive series. Follow along if you want to write faster, leaner C++. What's your go-to use case for string_view? Drop it below 👇 #cpp #cplusplus #programming #softwareengineering #performanceprogramming

Not so many people realize that in C++, allocation and construction are two separate things. When we write new, both steps usually happen together: - Memory is allocated - The object is constructed in that memory But internally, these are different operations. First, new uses the function ::operator new to allocate raw memory. It returns a void pointer if it succeeds, similar to C's malloc, but using the C++ memory model and throwing a std::bad_alloc if it fails. After that, once we have the memory allocated, new uses what is called "placement new" to create the object in that memory. The main idea is: ::operator new → allocates uninitialized raw memory placement new → constructs the object in that memory This is useful when working with: - custom allocators - memory pools - performance-critical systems For example, std::vector uses this with the member function emplace_back, which constructs the object directly on vector's reserved memory avoiding the need of creating first a temporary object. One important detail is that when using placement new, object destruction is manual too. Since no regular new/delete pair is involved, you usually need to call the destructor yourself. I like this part of C++ because it reveals something the language hides behind its syntax: memory allocation and object lifetime are closely related, but they are not the same thing.

Coding problem of the day Given a string s containing just the characters '(', ')', '{', '}', '[', ']', determine if the input string is valid. An input string is valid if: - Open brackets must be closed by the same type of brackets. - Open brackets must be closed in the correct order. - Every close bracket has a corresponding open bracket of the same type. Examples: - Input: "()" → Output: true - Input: "()[]{}" → Output: true - Input: "(]" → Output: false - Input: "([)]" → Output: false - Input: "{[]}" → Output: true - Input: "" (empty string) → Output: true Constraints: - 1 ≤ s.length ≤ 10^4 - s consists of parentheses only: '()[]{}'

I built a fully functional text editor in C++ from scratch — no libraries, no shortcuts. It supports multiple tabs, text selection, undo via cursor/anchor logic, search with match tracking, alignment (left, right, center, justify), auto and manual save and file save/load. The hardest part was designing the Wrapper and Layout system — formatting raw buffer text into well-aligned, column-aware lines without any external help. Everything is built on raw memory management with dynamic buffers and manual pointer arithmetic. This project taught me more about how software actually works under the hood than any tutorial ever could. Happy to discuss the architecture or any design decisions — drop a comment or message me! I am attaching the source code link below, to anyone who wants to explore and improve. Github: https://lnkd.in/dpB2yHPx #CPlusPlus #SystemsProgramming #SoftwareEngineering #BuildInPublic National University of Computer and Emerging Sciences

Day 168/365 – DSA Challenge 🚀 Solved Construct Binary Tree from Inorder and Postorder Traversal on LeetCode today. 🔹 Problem: Given two arrays — inorder and postorder traversal of a binary tree — construct the original tree. 🔹 Approach Used: Recursion Steps followed: 1️⃣ Last element of postorder → root 2️⃣ Find root in inorder 3️⃣ Split inorder into: Left subtree Right subtree 4️⃣ Build right subtree first, then left (because postorder is Left → Right → Root) 🔹 Key Idea: Postorder gives the root from the end, inorder gives the structure 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(n) 💻 Language: C++ Another classic tree construction problem — great for mastering recursion + traversal logic. #Day168 #365DaysOfCode #DSA #LeetCode #BinaryTree #Recursion #CodingChallenge #Cpp

C# switch went from a value comparator to a full pattern matching engine — and many devs missed that shift 👀 A few versions ago, switch could only match constants: strings, ints, case, break, done. Then C# 7 introduced type patterns and when guards — no more if (obj is int) chains, with additional conditions directly in case clauses. C# 8 turned switch into an expression that returns a value, and added property patterns — matching object properties with { } syntax instead of nested ifs. C# 9 brought relational and logical patterns: ranges like >= 70 and < 90, plus and, or, not combinators. No need for when workarounds in simple cases. C# 10 improved property patterns with extended syntax: Customer.IsPremium instead of { Customer: { IsPremium: true } }. C# 11 introduced list patterns — matching arrays by shape: ["deploy", var env, ..] without manual length checks. The result? I recently replaced a 47-line if-else chain with an 8-line switch expression ⚡ Same logic, clearer intent, compiler-checked exhaustiveness. If you haven't revisited pattern matching since C# 7, you're missing out on a big part of the language. #CSharp #DotNet #PatternMatching #CleanCode #SoftwareEngineering

🚀 𝗗𝗮𝘆 - 37/60 Problem: Count Binary Strings of Length n with No Consecutive 1’s 🔍 What I Learned: Today I learned how to solve counting problems using Dynamic Programming (DP). Initially, I tried generating all binary strings and checking for consecutive 1’s, but that’s inefficient and uses unnecessary space. The DP approach instead counts possibilities without generating strings, which is elegant and efficient. 💡 Logic Step by Step: Base Case (n = 1):ending0 = 1 → number of strings ending with 0 ("0") ending1 = 1 → number of strings ending with 1 ("1") Building Strings Iteratively (n ≥ 2):For each length from 2 to n: newEnding0 = ending0 + ending1 → We can append 0 to any previous string. newEnding1 = ending0 → We can append 1 only to strings ending with 0 (to avoid consecutive 1’s). Update Counts:ending0 = newEnding0 ending1 = newEnding1 This moves us to the next string length. Final Answer:Total valid strings = ending0 + ending1 😅 Struggles: Initially thought about generating strings manually. Didn’t understand why 1 could only follow strings ending with 0. Visualizing counts instead of actual strings was tricky at first. 🧠 Key Insights: Dynamic Programming solves bigger problems using smaller subproblem results. Counting possibilities can often replace generating all outcomes. Recognizing patterns like Fibonacci is critical for DP problems. 📦 Concepts Used: #DynamicProgramming #BinaryStrings #FibonacciPattern #CountingProblems #DSA #ProblemSolving

#Day-2 of 30 Days/30 Posts challenge. 👉 upgrading the C++ advanced concepts.... 💢 Tired of C++ initialization headaches? 😵💫 C++11 Uniform Initialization is your cure! C++11 didn’t just add features—it changed how we write C++. One feature that looks simple but is incredibly powerful: Uniform Initialization {} Before C++11, initialization was inconsistent and confusing: int x = 10; int x(10); int x = {10}; Now, with uniform initialization, we can use a single, consistent syntax: 👉 int x{10}; 💡 Why it matters: Prevents narrowing conversions (safer code) Makes initialization consistent across types Improves readability 🔹 Types of Uniform Initialization 👉 1. Direct Initialization int x{10}; 👉 2. Copy Initialization int x = {10}; 👉 3. Value Initialization int x{}; (Default initializes → x = 0) 👉 4. List Initialization (for containers) std::vector<int> v{1, 2, 3}; ⚠️ Important Insight Uniform initialization prevents unsafe conversions: int x{10.5}; // ❌ Error (narrowing not allowed) This is a big win for safety. 🧠 My takeaway What seems like a small syntax change actually enforces: 👉 Safer code 👉 Cleaner design 👉 Consistency across the language Modern C++ isn’t just about writing code—it’s about writing correct and expressive code. Still exploring more of C++11, one feature at a time 🚀 #CPP #ModernCPP #CPlusPlus #Programming #SoftwareEngineering #LearningJourney

I've finally started a deep dive into C++ templates. It's no news how incredibly powerful templates are; I've just not been able to fully master them. To be fair, templates have a steep learning curve and can certainly become complicated very quickly. On the bright side, the trade-off in flexibility and performance is often worth the effort. If you're asking how complicated it is? There's literally a 2500+ page book on C++ templates alone and several cppcon talks on it. You get the gist. For starters, a template in C++ is essentially a blueprint to tell the compiler how a function or a class should be defined (or created) at compile time. We basically tell the compiler to generate a family of functions or a family of classes during compile-time based on the parameterized type used during instantiation. Templates are similar to generics in other languages, albeit infinitely more powerful, flexible, and elegant than generics. Templates in C++ are a powerful mechanism for meta-programming since we get the compiler to generate code (or programs) based on the program we already wrote. One way I trivialize templates in my head is to assume that the compiler is running a subprogram during compilation. The output of this subprogram is executed as a part of the original program. So when you encounter a template definition in your code, pause and think of it as some process that runs during compilation. A key thing to note about templates: Templates are compiled using a two-phase compilation process: 1st phase: The compiler performs a static analysis of everything independent of the template parameters, static type checking, syntax, and grammar validation, non-templated signature validation, etc. 2nd Phase: The type is instantiated when the templated function or class is invoked. The compiler assesses the validity of the template parameters and the operations on these parameters. ref: https://lnkd.in/eZD-V3kE