|
|
By Alex, on August 11th, 2020 (h/t to reader Koe for providing the first draft of this lesson!)
In C++, all functions are classified as either non-throwing (do not throw exceptions) or potentially throwing (may throw an exception).
Consider the following function declaration:
|
|
int doSomething(); // can this function throw an exception or not? |
Looking at a typical function declaration, it is not possible to determine whether a function might throw . . . → Read More: 14.9 — Exception specifications and noexcept
By nascardriver, on January 30th, 2020 Depending on where you’re at in your journey with learning programming languages (and specifically, C++), LearnCpp.com might be the only resource you’re using to learn C++ or to look something up. LearnCpp.com is designed to explain concepts in a beginner-friendly fashion, but it simply can’t cover every aspect of the language. As you begin to . . . → Read More: S.4.4c — Using a language reference
By Alex, on January 3rd, 2020 Quick review
std::string offers an easy and safe way to deal with text strings. String literals are always placed between double quotes.
Enumerated types let us define our own type where all of the possible values are enumerated. These are great for categorizing things.
Enum classes work like enums but offer more type safety . . . → Read More: S.7.x — Chapter 7 summary and quiz
By Alex, on January 3rd, 2020 C++ supports two permutations on regular namespaces that are worth at least knowing about. We won’t build on these, so consider this lesson optional for now.
Unnamed (anonymous) namespaces
An unnamed namespace (also called an anonymous namespace) is a namespace that is defined without a name, like so:
|
|
#include <iostream> namespace // unnamed namespace { void doSomething() // can only be accessed in this file { std::cout << "v1\n"; } } int main() { doSomething(); // we can call doSomething() without a namespace prefix return 0; } |
This prints:
. . . → Read More: 6.17 — Unnamed and inline namespaces
By Alex, on January 3rd, 2020 Each block defines its own scope region. So what happens when we have a variable inside a nested block that has the same name as a variable in an outer block? When this happens, the nested variable “hides” the outer variable in areas where they are both in scope. This is called name hiding or . . . → Read More: 6.5 — Variable shadowing (name hiding)
By Alex, on January 3rd, 2020 In some applications, certain symbolic constants may need to be used throughout your code (not just in one location). These can include physics or mathematical constants that don’t change (e.g. pi or Avogadro’s number), or application-specific “tuning” values (e.g. friction or gravity coefficients). Instead of redefining these constants in every file that needs them (a . . . → Read More: 6.8 — Global constants and inline variables
By Alex, on January 3rd, 2020 In the prior lesson (6.6 — Internal linkage), we discussed how internal linkage limits the use of an identifier to a single file. In this lesson, we’ll explore the concept of external linkage.
An identifier with external linkage can be seen and used both from the file in which it is defined, and from other . . . → Read More: 6.7 — External linkage
By Alex, on January 3rd, 2020 In lesson 6.3 — Local variables, we said, “An identifier’s linkage determines whether other declarations of that name refer to the same object or not”, and we discussed how local variables have no linkage.
Global variable and functions identifiers can have either internal linkage or external linkage. We’ll cover the internal linkage case in this . . . → Read More: 6.6 — Internal linkage
By nascardriver, on January 3rd, 2020 Capture clauses and capture by value
In the previous lesson, we introduced this example:
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 |
#include <algorithm> #include <array> #include <iostream> #include <string_view> int main() { std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" }; auto found{ std::find_if(arr.begin(), arr.end(), [](std::string_view str) { return (str.find("nut") != std::string_view::npos); }) }; if (found == arr.end()) { std::cout << "No nuts\n"; } else { std::cout << "Found " << *found << '\n'; } return 0; } |
Now, let’s modify the nut example and let the user pick a substring to search for. This isn’t as intuitive as you might expect.
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 |
#include <algorithm> #include <array> #include <iostream> #include <string_view> #include <string> int main() { std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" }; // Ask the user what to search for. std::cout << "search for: "; std::string search{}; std::cin >> search; auto found{ std::find_if(arr.begin(), arr.end(), [](std::string_view str) { // Search for @search rather than "nut". return (str.find(search) != std::string_view::npos); // Error: search not accessible in this scope }) }; if (found == arr.end()) { std::cout << "Not found\n"; } else { std::cout << "Found " << *found << '\n'; } return 0; } |
This code won’t compile. Unlike nested blocks, where any identifier defined in an . . . → Read More: 7.16 — Lambda captures
By nascardriver, on January 3rd, 2020 Consider this snippet of code that we introduced in lesson 6.18 — Introduction to standard library algorithms:
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 |
#include <algorithm> #include <array> #include <iostream> #include <string_view> static bool containsNut(std::string_view str) // static means internal linkage in this context { // std::string_view::find returns std::string_view::npos if it doesn't find // the substring. Otherwise it returns the index where the substring occurs // in str. return (str.find("nut") != std::string_view::npos); } int main() { std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" }; // std::find_if takes a pointer to a function auto found{ std::find_if(arr.begin(), arr.end(), containsNut) }; if (found == arr.end()) { std::cout << "No nuts\n"; } else { std::cout << "Found " << *found << '\n'; } return 0; } |
This code searches through an array of strings looking for the first element that contains the substring “nut”. Thus, it produces the result:
Found walnut
And while it works, it could be improved.
The root of the . . . → Read More: 7.15 — Introduction to lambdas (anonymous functions)
|
|
