Noutați Archives | Page 14 of 190

November 3, 2023

Three Important Modern C++ Features That Can Be Used With C++ Builder

Noutați

Hello C++ Developers, this week, we have 3 more modern C++ features that can be used in C++ Builder. In C++14 you can store string in strings using modern programming methods. In the first post, we explain how you can preserve the string format especially when we use a string in a string with /”. Containers are powerful data storage arrays in modern C++ and they are very useful for iterating and searching data with their amazing methods and properties. In another post today we explain what the containers in modern C++ are, their types, and their methods. In C++14, there is a new decltype that is used with the auto keyword, and in the last post pick, we explain how you can use it. Our educational LearnCPlusPlus.org site has a broad selection of new and unique posts with examples suitable for everyone from beginners to professionals alike. It is growing well thanks to you, and we have many new readers, thanks to your support! The site features a treasure-trove of posts that are great for learning the features of modern C++ compilers with very simple explanations and examples. RAD Studio’s C++ Builder, Delphi, and their free community editions C++ Builder CE, and Delphi CE are powerful tools for modern application development. Table of Contents Where I can I learn C++ and test these examples with a free C++ compiler? How to use modern C++ with C++ Builder? How to learn modern C++ for free using C++ Builder? Do you want to know some news about C++ Builder 12? Where I can I learn C++ and test these examples with a free C++ compiler? If you don’t know anything about C++ or the C++ Builder IDE, don’t worry, we have a lot of great, easy to understand examples on the LearnCPlusPlus.org website and they’re all completely free. Just visit this site and copy and paste any examples there into a new Console, VCL, or FMX project, depending on the type of post. We keep adding more C and C++ posts with sample code. In today’s round-up of recent posts on LearnCPlusPlus.org, we have new articles with very simple examples that can be used with: The free version of C++ Builder 11 CE Community Edition or a professional version of C++ Builder or free BCC32C C++ Compiler and BCC32X C++ Compiler or the free Dev-C++ Read the FAQ notes on the CE license and then simply fill out the form to download C++ Builder 11 CE. How to use modern C++ with C++ Builder? In development, sometimes we want to preserve the string format especially when we use a string in a string with /”. In C++14 and above, there is a std::quoted template that allows handling strings safely where they may contain spaces and special characters and it keeps their formatting intact. In the first post, we explain the std::quoted template, and how you can use it with in examples. Containers are powerful data storage arrays in modern C++ and they are very useful to iterate and search data with their amazing methods and properties. The C++ Standards library defines 4 container types. In the next post, we explain containers and types in modern C++. The auto keyword arrives with the new features of C++11 and the standards above. In C++14, there is a new decltype that is used with the auto keyword. […]

November 1, 2023

[Yukon Beta Blog]: Win64 Clang Toolchains in RAD Studio 12

Noutați

This blog post is based on a pre-release version of the RAD Studio software and it has been written with specific permission by Embarcadero. No feature is committed until the product GA release. RAD Studio 12 is just around the corner, and we have exciting news to share! In August, we ran an unusual webinar where we shared a behind-the-scenes look at some technology we’ve been working on for C++Builder and the C++ side of RAD Studio. One of the things we previewed was an upgraded Clang-based Win64 compiler – though not just an upgrade but some major technological improvements to core areas, with a new STL, a new linker, and more. It is a thorough rework of the entire toolchain with a strong eye to making the right decisions for quality and longevity. Table of Contents New Clang Platform standards High performance for the compiled code. Optimised runtimes Excellent language standards compatibility. Excellent quality in all areas, such as exception handling A robust STL. A linker that can handle anything Tech details Status Toolchains in version 12.0 Overall New Clang The C++ compiler is foundational to RAD Studio. Through the Clang & LLVM work, we make LLVM available to Delphi. And, of course, we need a modern, powerful C++ compiler to provide our C++ developers with the best source compatibility, libraries, app performance, and more. Our goals for the work are: Very high quality. A robust STL. A linker that can handle anything and any quantity you give it. Excellent quality in all areas, such as exception handling Excellent language standards compatibility. High performance for the compiled code. Optimised runtimes. Match platform standards as much as possible How are we meeting those? Let’s go in reverse order. Platform standards The new toolchain is based on Clang 15*. The previous toolchain used the ELF object file format, a primarily Unix/Linux format, for historical reasons that are actually (long story) related to Kylix. For this toolchain, we are moving to COFF, which is the standard object file format for Windows compilers of any compiled language. Similarly, we are using the PDB debug format, which again is the standard. While we are not officially supporting any third party tools, there are many tools developers use which understand COFF & PDB and we hope that by adhering to the platform norms, we open up the opportunity to use a wide variety of tools with your apps and C++Builder. [*] Clang 15 was current when this work started, and we are avoiding changing the wheels while the car is in motion. We plan to remain up to date and move forward with Clang itself in future. High performance for the compiled code. While we are aiming for correct compiled code behaviour above all else, we are also aiming for high performance. The new toolchain’s technology generates more optimized code, and allows additional optimisations that were not previously possible in future. Optimised runtimes A C++ toolchain has multiple layers: a C runtime (providing things like printing to a console or file IO), a C++ runtime (providing things like exception handling), and the STL (providing C++ library functions like standard IO, algorithms, collections, etc.) For our toolchain, we are replacing all three. Image showing three layers of the C++ runtime: standard library, C++ RTL, and C […]

October 31, 2023

DevOps Halloween: Tricks and Treats

Noutați

The world of DevOps is like a labyrinth—filled with choices at every turn. Some paths lead to efficiency and success, while others may lead to unexpected challenges and delays. In the spirit of Halloween, let’s explore the tricks and treats of DevOps choices to ensure your team ends up with a bag full of treats rather than some nasty tricks. Version Control: Treats of Consistency, Tricks of Complexity Treat: Implementing a robust version control system is crucial for any DevOps team. Tools like Git provide a reliable way to track changes, collaborate on code and maintain a history of your project’s evolution. Trick: However, the complexity of these systems can lead to confusion and errors if not properly understood. Branching strategies, for instance, need to be clearly defined to avoid chaotic merges and lost work. Continuous Integration & Continuous Deployment (CI/CD): Speedy Treats, Tricky Configurations Treat: CI/CD pipelines automate the process of code integration, testing and deployment, speeding up release cycles and ensuring more reliable software. Trick: Setting up these pipelines can be complex and error-prone. Misconfigurations can lead to failed builds, delayed releases or even the deployment of buggy code to production. Containerization: The Sweetness of Isolation, Beware of the Overhead Treat: Containers provide isolated environments for applications, ensuring consistency across development, testing and production. Tools like Docker and Kubernetes have revolutionized application development and deployment. Trick: Containerization adds an additional layer of complexity to your infrastructure. Mismanagement of containers can lead to resource inefficiencies, and Kubernetes itself has a steep learning curve. Monitoring and Logging: The Treat of Visibility, The Trick of Overload Treat: Comprehensive monitoring and logging give teams visibility into system performance and behavior, enabling proactive issue resolution and performance optimization. Trick: The sheer volume of logs and metrics can be overwhelming. Without proper tools and strategies for filtering and analysis, important information can be lost in the noise. Infrastructure-as-Code (IaC): Sweet Automation, Sour Complexity Treat: IaC tools like Terraform and AWS CloudFormation allow teams to automate and version infrastructure setup, ensuring consistency and reducing manual errors. Trick: IaC scripts can become complex and difficult to maintain. Errors in these scripts can lead to misconfigured infrastructure, potential security issues and resource waste. Collaboration and Communication: Treats of Teamwork, Tricks of Misunderstanding Treat: DevOps emphasizes the importance of collaboration between development and operations teams, fostering a culture of shared responsibility and continuous improvement. Trick: Miscommunication and lack of alignment between teams can lead to inefficiencies, mistakes and a breakdown in the collaborative process. Security: The Unseen Specter Treat: DevSecOps enables a “shift left” on security, integrating security checks and practices early in the development life cycle, ensuring safer, more secure applications. Trick: But this integration requires continuous attention and maintenance. Outdated dependencies, misconfigured settings and inadequate security practices can leave your applications vulnerable, turning the unseen specter of security issues into a ghastly reality. What about you? What areas of DevOps are ripe for trick or treat this Halloween season? In the grand scheme, DevOps offers a treasure trove of benefits, from faster releases and improved collaboration to higher-quality software. However, it’s not without its challenges. Navigating the DevOps landscape requires a careful balance between embracing automation and maintaining control. By being aware of the potential tricks and focusing on the treats, teams can build efficient, reliable and […]

October 30, 2023

Research: Quantifying GitHub Copilot’s impact on code quality

Noutați

Today, we’re releasing new research on GitHub Copilot Chat. By using the power of natural language, developers in our study used GitHub Copilot Chat to get real-time guidance, tips, troubleshooting, remediation, and solutions tailored to their specific coding challenges—all in real time without leaving the IDE. Our research found that the quality of the code authored and reviewed was better across the board with GitHub Copilot Chat enabled, even though none of the developers had used the feature before. 85% of developers felt more confident in their code quality when authoring code with GitHub Copilot and GitHub Copilot Chat. Code reviews were more actionable and completed 15% faster with GitHub Copilot Chat. 88% of developers reported maintaining flow state with GitHub Copilot Chat because they felt more focused, less frustrated, and enjoyed coding more, too. Last year, our research uncovered that developers using GitHub Copilot code 55% faster. But working fast is just one part of the picture—in many cases, there has traditionally been a tradeoff between doing something quickly and doing something right. As artificial intelligence continues to write code for an increasing number of developers, ensuring good code quality is even more important. What does high-quality code look like? To measure code quality, we developed a rubric of five metrics used internally at GitHub, but that also align with academic and industry standards. Participants used the metrics to differentiate between strong code and code that slows them down. Readable Does the code follow the language’s idioms and naming patterns? Code that is difficult to read makes it more challenging to maintain, improve, and document. Reusable Is the code written so that it can be reused? Code reuse is a cornerstone of developer collaboration. It saves time and energy, breaks down silos, and creates consistency as a whole. Concise Does the code adhere to DRY (don’t repeat yourself)? The less repetitive the code is, the easier it’ll be to read, understand, and build upon. Complex code can lead to bugs and issues that will be tough to remediate. Maintainable Is the code written in a way that makes the functionality clear, transparent, and relevant to the problem at hand? Well-maintained code means that developers minimize dependencies. Maintainable code also impacts developers’ ability to search and practice code-reuse. Resilient Does the code anticipate and handle errors? Resilient code will maintain its functionality (or at least have minimal disruption) if there are errors. This goes a long way toward ensuring that code will, simply put, work. Using GitHub Copilot correlates with better code quality In this study, we investigated whether GitHub Copilot and its chatbot functionalities would improve perceived quality of the code produced, reduce time required to review the code, and produce code that passes unit testing. And by every measure, developers felt their coding improved when using GitHub Copilot. 85% of developers felt more confident in their code quality when authoring code with GitHub Copilot and Copilot Chat GitHub Copilot Chat is a chat interface that lets you interact with GitHub Copilot, to ask and receive answers to coding-related questions from directly within a supported IDE. The chat interface provides access to coding information and support without requiring you to navigate documentation or search online forums. Copilot Chat is currently supported in Visual Studio Code and Visual Studio. Here’s […]

October 28, 2023

Digital.ai Update Extends Scope and Reach of DevSecOps Platform

Noutați

Digital.ai this week made generally available a Denali update to its DevSecOps platform that promises to make it simpler to integrate custom artificial intelligence (AI) models with the AI models developed by the company. At the same time, the company is adding self-guided workflows and templates to generate tests and implement DevSecOps best practices along with integrations with Terraform by Hashicorp, Azure Bicep, Azure Key Vault and AWS Secrets Manager. Finally, Digital.ai is adding an ARM Protection feature to better secure iOS applications without requiring embedded bitcode or integrations into the build system. DevOps teams can, via a single command, protect compiled applications locally with support for obfuscation, run-time active protections and application monitoring without uploading them to a third-party service. Greg Ellis, general manager for application security for Digital.ai, said the overall goal is to make it simpler for software engineering teams to invoke capabilities that have been embedded within the company’s DevSecOps platform. In the case of AI models, that also means instead of requiring DevOps teams to only use AI models developed by Digital.ai, the company is moving to make it simpler for DevOps teams that adopt its platform to incorporate custom AI models as they see fit as part of an ongoing effort to democratize intelligence at scale, he noted. In general, it’s already apparent organizations will be employing heterogeneous approaches to incorporating AI models into DevOps workflows, said Ellis. The challenge now is moving beyond experimenting with AI to embedding them within DevOps workflows, he added. It’s already clear developers are using generative AI to develop code at increasingly faster rates. The challenge now is to manage that accelerated pace of development when many organizations are already struggling to manage existing DevOps workflows at scale. Hopefully, AI technologies will also one day help software engineers find ways to manage that volume of code moving across their DevOps pipelines. In the meantime, organizations will also need to better define where the machine learning operations (MLOps) workflows that data scientists use to build AI models end and where DevOps workflows that will be used to embed AI models into applications begin. As is often the case when it comes to emerging technologies, cultural issues are just as challenging as the implementation hurdles that need to be overcome. At this point, like it or not, the generative AI genie is out of the proverbial bottle. Just about every job function imaginable will be impacted to varying degrees. In the case of DevOps teams, the ultimate impact should involve less drudgery as many of the manual tasks that conspire to make managing DevOps workflows tedious are eliminated. Less clear is to what degree AI may drive organizations that have already embraced DevOps to adopt an alternative platform, but savvy DevOps teams are, at the very least, starting to map out which processes are about to be automated so they can have more time to focus on issues that add more value to the business.

October 28, 2023

How To Use Tuple Addressing Via Type In C++14 And Beyond

Noutați

The tuple ( std::tuple ) is a class template that stores the different types of elements, it also supports empty lists in modern C++. This template was introduced in C++11 and improved in C++14. In this post, we explain tuple addressing via type features that come with the C++14 standard. What is std::tuple in C++? The tuple ( std::tuple) is a class template a fixed-size collection of different types of values like floats, integers, texts, etc. and it is defined in the tuple header. In another term tuple stores the different types of elements, it also supports empty lists. This template has been available since C++11 and improved in C++14, and C++20 standards. In C++ programming, the std::tuple is a generalization of std::pair. The destructor of the tuple is trivial if std::is_trivially_destructible::value is set to true for every type in Types. What is the syntax for std::tuple in C++? Here is the syntax of std::tuple in C++, template class tuple; Is there a C++ std::tuple example, how can we use tuples? Here is a example to define different types of members in a my_tuple, std::tuple my_tuple { “text one”, 9, 2.22, “text two”, 15 , 7.88, “text three”}; std::cout

October 28, 2023

ICYMI: improved C++ vulnerability coverage and CodeQL support for Lombok

Noutați

In the ever-evolving software development landscape, static application security solutions face a unique challenge: as applications grow in complexity, they rely heavily on a diverse array of libraries, frameworks, and custom code. Ensuring the security of such intricate systems requires a meticulous approach—and not all solutions are created equal. The effectiveness of a static application security solution hinges on its ability to provide extensive vulnerability coverage and support for a wide range of languages and frameworks. Code scanning, for example, is equipped with broad coverage for the most popular languages and frameworks and can scrutinize all parts of the codebase, leaving no stone unturned. This approach leads to the identification of an expansive array of vulnerabilities, including those specific to certain technologies or development patterns. The result is a more thorough and reliable assessment of an organization’s security posture. We’re always looking for ways to help you detect more vulnerabilities in your codebase, so today, we’re highlighting two releases aimed at providing better coverage for both languages and frameworks, improved C++ vulnerability coverage and Lombok support. Improved C++ vulnerability coverage Detecting vulnerabilities in C++ code is uniquely challenging because of the language’s low-level memory manipulation, complexity, undefined behavior, platform discrepancies, and the absence of built-in memory safety features. Legacy code, concurrency issues, and dynamic memory allocation further compound this difficulty. Addressing these vulnerabilities must be done with precision, including rigorous code reviews, extensive testing, and the adoption of secure coding practices. CodeQL for C and C++ has recently gained increased support for detecting complex memory corruption vulnerabilities. Broadly speaking, these vulnerabilities are all related to dereferencing pointers that should not be dereferenced at a given point in the code. For those who are interested in delving deeper into the technical aspects of this topic, below we’ll explore a couple of new kinds of vulnerabilities CodeQL can now detect. An in depth look at CodeQL’s new C++ vulnerability coverage The default query suite can now detect double-free and use-after-free vulnerabilities using the queries cpp/double-free and cpp/use-after-free. These are classic memory corruption issues that C and C++ developers constantly have to keep in mind to avoid creating serious security incidents. In addition, the default query suite now also detects dereferences that look suspicious in general using the query cpp/redundant-null-check-simple. Finding “suspicious dereferences” in general is very hard since there are so many ways to make the dereference “obviously” safe. The query gets around these problems by finding dereferences that are always performed regardless of the result of a null check, or where a null check is always performed after the dereference (which suggests that the pointer may, in fact, sometimes be null). The security-extended suite has also gained much better support for reasoning about buffer overflows with two new queries cpp/overrun-write and cpp/invalid-pointer-deref, which detect different kinds of pointer dereferences that may be out of bounds. Both cpp/invalid-pointer-deref and cpp/overrun-write perform a novel analysis that finds the size of an allocation by doing two “parallel” dataflow analyses (one dataflow analysis to track the pointer and another dataflow analysis to track the size of the allocation), which enable us to find places in the code where a pointer dereference is incorrectly guarded. Such “off by one” errors are very common, and we have confirmed that cpp/invalid-pointer-deref finds existing CVEs such as https://www.cvedetails.com/cve/CVE-2018-14599/. This […]

October 26, 2023

Win64 Clang Toolchains in RAD Studio 12

Noutați

This blog post is based on a pre-release version of the RAD Studio software and it has been written with specific permission by Embarcadero. No feature is committed until the product GA release. RAD Studio 12 is just around the corner, and we have exciting news to share! In August, we ran an unusual webinar where we shared a behind-the-scenes look at some technology we’ve been working on for C++Builder and the C++ side of RAD Studio. One of the things we previewed was an upgraded Clang-based Win64 compiler – though not just an upgrade but some major technological improvements to core areas, with a new STL, a new linker, and more. It is a thorough rework of the entire toolchain with a strong eye to making the right decisions for quality and longevity. Table of Contents New Clang Platform standards High performance for the compiled code. Optimised runtimes Excellent language standards compatibility. Excellent quality in all areas, such as exception handling A robust STL. A linker that can handle anything Tech details Status Toolchains in version 12.0 Overall New Clang The C++ compiler is foundational to RAD Studio. Through the Clang & LLVM work, we make LLVM available to Delphi. And, of course, we need a modern, powerful C++ compiler to provide our C++ developers with the best source compatibility, libraries, app performance, and more. Our goals for the work are: Very high quality. A robust STL. A linker that can handle anything and any quantity you give it. Excellent quality in all areas, such as exception handling Excellent language standards compatibility. High performance for the compiled code. Optimised runtimes. Match platform standards as much as possible How are we meeting those? Let’s go in reverse order. Platform standards The new toolchain is based on Clang 15*. The previous toolchain used the ELF object file format, a primarily Unix/Linux format, for historical reasons that are actually (long story) related to Kylix. For this toolchain, we are moving to COFF, which is the standard object file format for Windows compilers of any compiled language. Similarly, we are using the PDB debug format, which again is the standard. While we are not officially supporting any third party tools, there are many tools developers use which understand COFF & PDB and we hope that by adhering to the platform norms, we open up the opportunity to use a wide variety of tools with your apps and C++Builder. [*] Clang 15 was current when this work started, and we are avoiding changing the wheels while the car is in motion. We plan to remain up to date and move forward with Clang itself in future. High performance for the compiled code. While we are aiming for correct compiled code behaviour above all else, we are also aiming for high performance. The new toolchain’s technology generates more optimized code, and allows additional optimisations that were not previously possible in future. Optimised runtimes A C++ toolchain has multiple layers: a C runtime (providing things like printing to a console or file IO), a C++ runtime (providing things like exception handling), and the STL (providing C++ library functions like standard IO, algorithms, collections, etc.) For our toolchain, we are replacing all three. Image showing three layers of the C++ runtime: standard library, C++ RTL, and C […]

October 25, 2023

Stacklet Applies Generative AI to Simplify Cloud Governance

Noutați, Software

Stacklet today provided early access to a Jun0 tool that leverages generative artificial intelligence (AI) to improve cloud governance and reduce costs. Stacklet CEO Travis Stanfield said the goal is to make it possible to automatically surface recommendations and implement policies using a mix of large language models (LLMs) trained using data collected via the company’s Stacklet AssetDB database. Accessed via a natural language interface, Jun0 makes it possible to declaratively govern cloud computing environments via text-based queries to generate policies that can be implemented as code; that eliminates the need for specialized programming expertise, he added. IT teams can use text to launch queries pertaining to any operations, cost, security and compliance issues and then visually test the policies created as part of a dry run before implementing them at scale. In effect, Jun0 substantially reduces the level of expertise required to successfully manage cloud computing environments by making it simpler to create governance policies, noted Stanfield. DevOps teams are generally tasked with making sure cloud computing environments are optimally managed using policies that are usually implemented as code within a DevOps workflow. Implementing policy-as-code, however, typically involves mastering a domain-specific programming language. Stacklet is now making a case for a higher level of abstraction that eliminates the need to master yet another programming language to govern cloud computing environments. It’s still early days as far as the adoption of generative AI is concerned within DevOps workflows, but it’s already clear that implementing best practices is about to become substantially easier. In essence, DevOps practices are about to become democratized in a way that reduces the cognitive load required to implement them. In addition to increasing the number of application environments a DevOps team may be able to effectively manage, generative AI will make DevOps accessible to a wider range of organizations that previously would not have been able to hire and retain software engineers. Many of those software engineers should also be able to spend more time addressing more complex issues rather than, for example, writing scripts to ensure that only certain classes of workloads are allowed to run on a particular cloud service within a period of time which results in lower costs. Unfortunately, DevOps teams are already playing catch-up when it comes to having access to generative AI tools. Developers are already taking advantage of generative AI tools to create more code faster. As that code moves through DevOps pipelines, it’s apparent the overall size of the codebase that DevOps teams are being required to manage is only going to increase. Most organizations are not going to be able to hire a small army of software engineers to manage that codebase, so the tooling provided to existing DevOps teams will need to improve. The issue now is narrowing the gap between now and when next-generation AI tools are made generally available. One way or another, however, it’s clear that the way DevOps is managed will never be the same again.

October 25, 2023

Learn About Useful Shared Mutexes Locking In Modern C++

C++ Builder

A concurrency support library is designed to solve problems in modern C++ that arise with multi-thread development. This library includes built-in support for threads (std::thread), atomic operations (std::atomic), mutual exclusion (std::mutex), condition variables (std::condition_variable), and many other features. In C++14, in addition to mutex, there is a shared_mutex which is an instance of the class located in header. In this post, we explain using shared mutexes locking in Modern C++. What is a mutex (mutual exclusion) in C++? Mutual Exclusion is a property of concurrency control and in programming, the Mutual Exclusion is a data exclusion method to lock and unlock data that provides exclusive access to a resource. This is mostly needed when we use shared data in multi-thread and multi-task operations in parallel programming. In C++, we can use std::mutex to define mutex data variables to protect his shared data from being simultaneously accessed by multiple threads. Here is an example of how we can use std::mutex with its lock() and unlock() methods, std::mutex mtx; mtx.lock(); // do operations mtx.unlock(); What is a shared mutex in modern C++? The shared mutex comes with C++14, it is an instance of the class located in header and used with the shared_mutex class name in mutual exclusion operations of threads. The shared_mutex class is a part of the thread support library, it is a synchronization primitive for the thread operations that can be used to protect shared data when multiple threads try to access. Here is how we can define a shared mutex by using std::shared_mutex. std::shared_mutex ; Is there an example about shared mutexes (std::shared mutex)? Here is a simple example about std::shared_mutex with its try_lock_shared() and unlock_shared() methods that comes with C++17. std::shared_mutex sharedmutex; // in a thread function sharedmutex.try_lock_shared(); // do operations sharedmutex.unlock_shared(); How to use shared lock unlock mutexes methods? A shared_mutex has lock() and unlock() methods as in mutex type, In C++17, it is improved and supports the additional methods lock_shared, unlock_shared, and try_lock_shared. Simply these are: lock_shared (C++17) The lock_shared method is used to block the calling thread until the thread obtains shared ownership of the mutex. unlock_shared (C++17) The unlock_shared method is used to release shared ownership of the mutex held by the calling thread. try_lock_shared (C++17) The try_lock_shared method is used to obtain shared ownership of the mutex without blocking. Return type is can be true if the method obtains ownership, or false if it cannot. Is there a full example of how to use shared mutexes (std::shared mutex) in C++? Let’s assume that we have a global val and we read data by a getv() and we write data by putv() functions, and we run these functions in threads. Here is a full and simple example about shared mutexes (std::shared mutex). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 #include #include #include #include std::shared_mutex sharedmutex; int val=500; void putv( int v ) { sharedmutex.lock(); std::this_thread::sleep_for(std::chrono::microseconds(2)); //some latency simulation val = v; sharedmutex.unlock(); } void getv( int &v ) { sharedmutex.lock_shared(); std::this_thread::sleep_for(std::chrono::microseconds(2)); // some latency simulation v = val; sharedmutex.unlock_shared(); } int main() { int readval; std::thread t1( getv , std::ref( readval ) ); std::thread t2( putv , 100); […]

Abonează-te la noutăți