Mirrors/CppCoreGuidelines
1
0
Fork 0
mirror of https://github.com/isocpp/CppCoreGuidelines.git synced 2025-12-17 20:54:41 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Consistently use simple function name for meaningless functions

Browse Source
This commit is contained in:
Thibault Kruse
2016-04-17 13:37:06 +02:00
parent e910836f3b
commit c4698f22fe
1 changed files with 10 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
CppCoreGuidelines.md
View File

@@ -371,7 +371,7 @@ The second version leaves the reader guessing and opens more possibilities for u
##### Example ##### Example
void do_something(vector<string>& v) void f(vector<string>& v)
{ {
string val; string val;
cin >> val; cin >> val;
@@ -388,7 +388,7 @@ The second version leaves the reader guessing and opens more possibilities for u
That loop is a restricted form of `std::find`. That loop is a restricted form of `std::find`.
A much clearer expression of intent would be: A much clearer expression of intent would be:
void do_something(vector<string>& v) void f(vector<string>& v)
{ {
string val; string val;
cin >> val; cin >> val;
@@ -2308,13 +2308,13 @@ When copying is cheap, nothing beats the simplicity and safety of copying, and f
##### Example ##### Example
void fct(const string& s); // OK: pass by reference to const; always cheap void f1(const string& s); // OK: pass by reference to const; always cheap
void fct2(string s); // bad: potentially expensive void f2(string s); // bad: potentially expensive
void fct(int x); // OK: Unbeatable void f3(int x); // OK: Unbeatable
void fct2(const int& x); // bad: overhead on access in fct2() void f4(const int& x); // bad: overhead on access in f4()
For advanced uses (only), where you really need to optimize for rvalues passed to "input-only" parameters: For advanced uses (only), where you really need to optimize for rvalues passed to "input-only" parameters:
@@ -7259,7 +7259,7 @@ The members of a scoped object are themselves scoped and the scoped object's con
The following example is inefficient (because it has unnecessary allocation and deallocation), vulnerable to exception throws and returns in the `...` part (leading to leaks), and verbose: The following example is inefficient (because it has unnecessary allocation and deallocation), vulnerable to exception throws and returns in the `...` part (leading to leaks), and verbose:
void some_function(int n) void f(int n)
{ {
auto p = new Gadget{n}; auto p = new Gadget{n};
// ... // ...
@@ -7268,7 +7268,7 @@ The following example is inefficient (because it has unnecessary allocation and
Instead, use a local variable: Instead, use a local variable:
void some_function(int n) void f(int n)
{ {
Gadget g{n}; Gadget g{n};
// ... // ...
@@ -10971,7 +10971,7 @@ In such cases, "crashing" is simply leaving error handling to the next level of
##### Example ##### Example
void do_something(int n) void f(int n)
{ {
// ... // ...
p = static_cast<X*>(malloc(n,X)); p = static_cast<X*>(malloc(n,X));
@@ -10981,7 +10981,7 @@ In such cases, "crashing" is simply leaving error handling to the next level of
Most systems cannot handle memory exhaustion gracefully anyway. This is roughly equivalent to Most systems cannot handle memory exhaustion gracefully anyway. This is roughly equivalent to
void do_something(Int n) void f(Int n)
{ {
// ... // ...
p = new X[n]; // throw if memory is exhausted (by default, terminate) p = new X[n]; // throw if memory is exhausted (by default, terminate)