C++: Difference between revisions
(17 intermediate revisions by the same user not shown) | |||
Line 81: | Line 81: | ||
===String=== | ===String=== | ||
<code>#include <string></code><br> | <code>#include <string></code><br> | ||
If you don't need to own the string, prefer to use <code>string_view</code>. | |||
<syntaxhighlight lang="cpp"> | <syntaxhighlight lang="cpp"> | ||
Line 189: | Line 191: | ||
[https://insanecoding.blogspot.com/2011/11/how-to-read-in-file-in-c.html Reference and comparison of different methods] | [https://insanecoding.blogspot.com/2011/11/how-to-read-in-file-in-c.html Reference and comparison of different methods] | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
#include <cerrno> | |||
#include <fstream> | #include <fstream> | ||
#include <string> | #include <string> | ||
#include < | #include <string_view> | ||
std::string get_file_contents( | std::string get_file_contents(std::string_view filename) { | ||
{ | |||
std::ifstream in(filename, std::ios::in | std::ios::binary); | std::ifstream in(filename, std::ios::in | std::ios::binary); | ||
if (in.good()) | if (in.good()) { | ||
std::string contents; | std::string contents; | ||
in.seekg(0, std::ios::end); | in.seekg(0, std::ios::end); | ||
Line 264: | Line 265: | ||
Smart pointers were added in C++11.<br> | Smart pointers were added in C++11.<br> | ||
There are 3 types of smart pointers: | There are 3 types of smart pointers: | ||
* | * [https://en.cppreference.com/w/cpp/memory/unique_ptr <code>std::unique_ptr</code>] - one piece of code ''owns'' the memory at any given time.<br> | ||
* <code>std::shared_ptr</code> - the memory has multiple owners. | |||
* <code>std::weak_ptr</code> - a non-owning reference to a shared_ptr. | |||
In general, there should be one object owning an object using a <code>unique_ptr</code>. Whenever you pass the value around, other functions should receive the object as a reference making it clear that they do not have ownership of the object. Smart pointers are nullable and assignable similar to regular pointers. | |||
Prefer to use <code>make_unique</code> or <code>make_shared</code> which will only make one memory allocation for both the object and the pointer rather than two memory allocations.<br> | |||
You can call <code>my_ptr.reset(new Car())</code> to change the pointer or <code>my_ptr.reset()</code> to deallocate the object referenced by the pointer. | |||
Example: | Example: | ||
<syntaxhighlight lang="cpp"> | <syntaxhighlight lang="cpp"> | ||
Line 418: | Line 420: | ||
===Chrono=== | ===Chrono=== | ||
<code>#include <chrono></code><br> | <code>#include <chrono></code><br> | ||
I now prefer using <code>absl::Time</code> and <code>absl::Duration</code> over Chrono because they abstract away the underlying type. | |||
<syntaxhighlight lang="cpp"> | <syntaxhighlight lang="cpp"> | ||
auto start = std::chrono::high_resolution_clock::now(); | auto start = std::chrono::high_resolution_clock::now(); | ||
Line 459: | Line 463: | ||
std::cout << '\n'; | std::cout << '\n'; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
===const=== | |||
For variables: | |||
# Use <code>constexpr</code> for values initialized at compile time and won't change at runtime. Most of the time, this is what you want for hardcoded compile time parameters. | |||
# Use <code>const</code> for values initialized at runtime and won't change. | |||
# Use <code>constinit</code> for values initialized at compile time and may change at runtime. I haven't found a use case for this yet. | |||
For functions: | |||
# Add <code>const</code> to the end of a method declaration if it won't change the object. | |||
# Add <code>constexpr</code> if the function can be evaluated at compile time, i.e. can accepts and output <code>constexpr</code> variables. | |||
# Add <code>consteval</code> if you want to force the function to only be evaluated at compile time. | |||
==STL== | ==STL== | ||
Line 643: | Line 658: | ||
** I.e. each object should manage it's own memory rather than the caller having to manage it. | ** I.e. each object should manage it's own memory rather than the caller having to manage it. | ||
** You should never use `malloc` and `free` unless interfacing with C libraries. | ** You should never use `malloc` and `free` unless interfacing with C libraries. | ||
* | * Avoid the use of new and delete, instead using vector or smart pointers. | ||
* Use clang-format. | * Use clang-format. | ||
Line 656: | Line 670: | ||
Resource Acquisition Is Initialization - binds the life cycle of a resource to the lifetime of an object.<br> | Resource Acquisition Is Initialization - binds the life cycle of a resource to the lifetime of an object.<br> | ||
For instance, the resource for a vector is an allocated amount of memory. Once the vector is destroyed and the destructor called, the resource is released.<br> | For instance, the resource for a vector is an allocated amount of memory. Once the vector is destroyed and the destructor called, the resource is released.<br> | ||
[[Wikipedia: Rule of three (C++ programming) | Rule of three]] | If you need any from one of the rules, you need to implement the remainder | ||
;Rule of zero<br> | |||
Do not use a custom deconstructor, copy constructor, or copy assignment. Push all of these operations into the classes of member variables such as <code>std::vector</code> and <code>unique_ptr</code>. This is the best and simplest case. | |||
;[[Wikipedia: Rule of three (C++ programming) | Rule of three]] | |||
* Destructor | * Destructor | ||
* Copy constructor | * Copy constructor | ||
* | * Copy assignment operator | ||
[[Wikipedia: Rule of three (C++ programming)#Rule of five | Rule of five]] | ;[[Wikipedia: Rule of three (C++ programming)#Rule of five | Rule of five]] | ||
* All from rule of three plus: | |||
* Move constructor | * Move constructor | ||
* Move operator | |||
;Rule of four and a half: | |||
* Destructor | |||
* Copy constructor | |||
* Copy-and-swap assignment operator | |||
* Swap function | * Swap function | ||
{{hidden | Example RAII Class | | {{hidden | Example Rule of Four RAII Class | | ||
Copied from [https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom stack overflow] | Copied from [https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom stack overflow] | ||
<syntaxhighlight lang="cpp"> | <syntaxhighlight lang="cpp"> | ||
Line 742: | Line 766: | ||
{{main | Eigen (C++ library)}} | {{main | Eigen (C++ library)}} | ||
A header-only C++ linear algebra library. | A header-only C++ linear algebra library. | ||
===absl=== | |||
https://github.com/abseil/abseil-cpp is a library used by Google which supplements the standard library. | |||
Useful things: | |||
# <code>absl::Time</code> and <code>absl::Duration</code>. | |||
# [https://abseil.io/docs/cpp/guides/strings#abslstrcat absl strings] | |||
# [https://abseil.io/docs/cpp/guides/logging absl logging] | |||
Many parts of absl now have <code>std::</code> equivalents such as <code>std::unique_ptr</code>, <code>std::string_view</code>, <code>std::span</code>. Unless contributing to Google codebases, you should probably prefer those. | |||
At Google, they prefer absl hash containers over unordered_set and unordered_map: | |||
# <code>absl::flat_hash_map</code> | |||
==References== | ==References== | ||
[[Category:Programming languages]] | [[Category:Programming languages]] |