C/C++ Programming
A collection of advanced C and C++ programming articles focusing on modern language features, template design, RAII, memory management, performance optimisation, and real-world systems engineering. Ideal for developers working on high-performance, low-latency, or embedded applications.
The author successfully installed the GCC 16.1 compiler on an Ubuntu machine, outlining the installation steps and necessary dependencies. Following installation, a sample C++26 program utilizing reflection was compiled and executed without issues, demonstrating the new features of the compiler. The process and the author's excitement for the new capabilities are detailed.
The content discusses the challenges of processing sensor data in embedded software using traditional loops, highlighting issues with complexity and error management. It introduces the advantages of C++20's std::ranges, allowing for cleaner, more efficient data processing through a chain of filters and transformations without convoluted logic, while emphasizing potential drawbacks of relying on views.
C++17 introduced std::optional to improve API design by allowing functions to return an optional value. Instead of returning a placeholder like -1 when a key isn't found in a map, std::optional lets functions return std::nullopt. C++23 further enhances error handling with std::expected, allowing custom error messages.
The post discusses building a multithreaded HTTP web server in C++ using a thread pool to handle concurrent connections, Nginx as a reverse proxy, and Docker for containerization. The server manages shared state with mutexes and condition variables, ensuring thread safety. Key features include live management, health checks, and rate limiting.
The discussion centers on returning std::vector from C++ functions, highlighting Return Value Optimization (RVO) introduced in C++17. RVO allows the compiler to avoid copying vectors by constructing them in place when there's a single return path. For multiple return paths, std::move is used to transfer ownership efficiently. Exceptions exist, particularly with the conditional operator, which requires copying. Returning references from member functions is safer than from free functions since the object's lifetime ensures validity.
In multi-threaded programming, protecting shared resources is crucial. std::mutex is common, but may bottleneck performance when many readers access data. std::shared_mutex can optimize scenarios with many readers and few writers, though its advantages depend on thread concurrency. Understanding the workload's read/write balance is key for effective synchronization.
This post discusses the importance of efficient data handling in modern C++, exploring methods of passing contiguous data buffers to functions, including raw pointers, std::vector, std::array, and the C++20 feature std::span. It highlights the strengths and weaknesses of each method, emphasizing std::span's benefits for safe, flexible data management without ownership.
Choosing an appropriate C++ container impacts memory layout, cache efficiency, and access patterns, vital for performance. Common comparisons include std::vector, std::deque, std::array, std::list, std::map, and std::unordered_map. The choice should align with data access and modification requirements, ensuring optimal performance for diverse workloads, from iteration to key-based access.
Acronyms, like RAII (Resource Acquisition Is Initialization), can be intimidating for programmers but reveal their elegance once understood. RAII ties resource management to object lifetime, ensuring reliable cleanup even during exceptions. This blog illustrates its significance through examples, emphasizing its role in modern C++ and urging developers to adopt its principles.
In this chapter, we will learn various aspects of class template instantiation. Understanding the class template instantiation is pivotal to the overall understanding of the functioning of templates in general. The fundamental concept of template instantiation remains the same for both function templates and class templates. However, instantiation of class template instantiation is more complex than function template.
C++ templates are a powerful tool for writing flexible and reusable code, enabling type-independent programming. This guide covers everything from basic template syntax to advanced concepts like class templates, function return types, and instantiation. Whether you're new to templates or looking to refine your skills, each chapter provides clear explanations and practical insights. Dive in and unlock the full potential of C++ templates to write more efficient and scalable programs.
The content outlines seven chapters on C++ templates, covering introductory concepts, function templates, template parameters, return types, miscellaneous aspects, class templates, and class template instantiation. Each chapter provides a foundation for understanding and effectively using templates in C++. Additionally, it mentions the availability of source code.
In the first section of the book, we have learned about the basic syntax and usage of a function template. In this second part of the book, we will focus on the class templates. Class templates are an essential tool for the programmer to design classes that can work on the generic data type. While class templates are an excellent tool for the programmers, it is slightly complex than the function templates. The syntax and usage may look a bit daunting for new programmers. In this chapter, we will learn about how to declare and define classes with templated parameters step by step with simple examples at each step.
In this chapter we will cover the following topics - Understanding difference between declaration and definition, Compiling and linking of template function, Organizing template function code, Abbreviated function templates, Overloading template function.
This chapter will discuss the various ways we can declare or deduce the return type of a template function. We can use either template or non-template parameters to declare the return type of a function template. We can also deduce the return type using keywords like auto and decltype. In some cases, we can declare a separate type parameter for the return type. Because of these intricacies, it is necessary to discuss the template function’s return type in detail with specific examples tailored for each case.
Chapter 3: All About Template Parameters in C++ Type parameters, non-type parameters, and multiple template parameters in practice Vivek Bhadra · C++17 · Templates · …
Continue reading → Chapter 3: All About Template Parameters in C++
Chapter 2: Working with Function Templates in C++ Syntax, two-phase compilation, instantiation, and explicit argument specification Vivek Bhadra · C++17 · …
Continue reading → Chapter 2: Working with Function Templates in C++
C++ templates are intimidating for any beginner or intermediate level programmer as it is syntactically a bit cryptic and complex. Also, there are intricacies in how to use the powerful features of the language. A standard C++ book does not always go into the feature’s details instead of just touching upon the subject, which is not sufficiently explanatory for the first-time learners. Sometimes the examples are too complicated, or the explanations are too vague to understand. Often, there are not many different sample codes to practice enough to have a good grip on the subject. In other cases, the available books go so deep into the nitty-gritty of the language that the reader feels a bit lost in the sea of information. In either way, the subject seems daunting for the newbies or intermediate-level programmers. However, if we explain it systematically with simple examples and easy-to-understand explanations, the C++ template could be a powerful tool for programmers. Proper use of templates can lead to clean, elegant, and efficient code on many occasions. The reader should be a beginner or intermediate-level programmer who has a basic understanding of C++ programming. They do not need to have detailed, in-depth knowledge or vast experience on the subject but should be familiar with the C++ programming paradigm’s basic concepts and be looking to take it to the next level.
This blog is about how to launch a Linux shell command inside a C++ program.
Operator overloading is one of the fundamental operation which come across often in a C++ program. It is bit cryptic in syntactical side as well as often a misunderstood topic amongst new programmer. I will try to explain this as a series of C++ related notes (as I like to call this) following this post.
Install the custom Toolchain Download and install the toolchain rpm sudo alien ~/Downloads/<toolchain-name>.rpm sudo dpkg -i ./<toolchain-name>.deb Locate the arm compiler sudo find / -iname…
How to install pre-build binaries with cmake without forced to be recompile it again.
I do not have administrative rights on a linux server (openSuse Linux) I am working on right now. So installing anything is not an option…
The post discusses the advantages of using threads over separate processes, specifically in data sharing and communication. It highlights a scenario where a song title in a word processor can easily be accessed by a music player when both run as threads within the same process. The introduction of the pthread library is significant for managing threads in C. It demonstrates the use of pthread_create() to create threads and emphasizes the importance of pthread_join() to ensure proper synchronization, thereby preventing premature termination of threads. The post concludes by mentioning upcoming discussions on synchronization challenges like race conditions.
Thread-safety of a function refers to the fact whether a function can be safely called from multiple threads simultaneously. Safety here means that even if multiple threads are executing the function simultaneously the data integrity is intact and is not intermingled.
Memory leak is a phenomenon where a running C/C++ program or a running process or thread dynamically allocates memory block from the heap but fails to free the memory block when it no more requires the memory. This happens due to programmatic error where the handle to the allocated memory block gets lost. Over a time if the same programmatic entity (a process, or a thread or a function) comes into action repeatedly and leaks memory, all the free memory of the systems goes away and eventually the systems throws the dreaded "Out Of Memory" and crumbles down.
valgrind is a popular tool which can detect memory in run-time. This blog post discusses how to install, and run valgrind at linux command line to detect memory leak in a sample C program.
This blog post discusses the polymorphism with the help of C++ language. The mechanism to implement polymorphism in C++ is known as Virtual Functions. With the help of a simple example I will try to explain the concept as clearly as I can.
Why virtual functions are required in C++.
Auto variable An auto variable is a variable which is declared within the scope of a function. We call it local variable as well.…
Continue reading → Auto, static and global variable in C/C++ programming
[code language="cpp"] #include <iostream> #include <sstream> #include <stdio.h> #include <string> using namespace std; template <typename T> class Stack { private: int top; T datastore[100]; public:…
Continue reading → Write a program to convert a decimal number to its binary equivalent using stack.
[code language="cpp"] #include <iostream> #include <sstream> #include <stdio.h> #include <string> using namespace std; template <typename T> class Stack { private: int top; T datastore[100]; public:…
Continue reading → Write a program to check if a word is a palindrome using stack.