adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-11-23 06:03:07 +03:00
Code Issues Projects Releases Wiki Activity

[c++/en] remove using namespace std (#4738)

Browse Source
This commit is contained in:
rilysh 2024-05-17 23:16:56 +05:30 committed by GitHub
parent 89857f5e24
commit 825a2b0875
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 74 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
c++.html.markdown
View File

@ -31,7 +31,7 @@ one of the most widely-used programming languages.
// Comparison to C
//////////////////
// C++ is _almost_ a superset of C and shares its basic syntax for
// C++ is almost a superset of C and shares its basic syntax for
// variable declarations, primitive types, and functions.
// Just like in C, your program's entry point is a function called
@ -55,24 +55,26 @@ int main(int argc, char** argv)
// However, C++ varies in some of the following ways:
// In C++, character literals are chars
sizeof('c') == sizeof(char) == 1
// In C++, character literals are chars, therefore the size is 1
sizeof('c') == sizeof(char)
// In C, character literals are ints
// In C, character literals are ints, therefore the size is 4
sizeof('c') == sizeof(int)
// C++ has strict prototyping
void func(); // function which accepts no arguments
void func(void); // same as earlier
// In C
void func(); // function which may accept any number of arguments
void func(); // function which may accept any number of arguments with unknown type
void func(void); // function which accepts no arguments
// Use nullptr instead of NULL in C++
int* ip = nullptr;
// C standard headers are available in C++.
// C headers end in .h, while
// Most C standard headers are available in C++.
// C headers generally end with .h, while
// C++ headers are prefixed with "c" and have no ".h" suffix.
// The C++ standard version:
@ -101,7 +103,7 @@ void print(char const* myString)
void print(int myInt)
{
printf("My int is %d", myInt);
printf("My int is %d\n", myInt);
}
int main()
@ -193,22 +195,24 @@ int main()
#include <iostream> // Include for I/O streams
using namespace std; // Streams are in the std namespace (standard library)
int main()
{
int myInt;
// Prints to stdout (or terminal/screen)
cout << "Enter your favorite number:\n";
// std::cout referring the access to the std namespace
std::cout << "Enter your favorite number:\n";
// Takes in input
cin >> myInt;
std::cin >> myInt;
// cout can also be formatted
cout << "Your favorite number is " << myInt << '\n';
std::cout << "Your favorite number is " << myInt << '\n';
// prints "Your favorite number is <myInt>"
cerr << "Used for error messages";
std::cerr << "Used for error messages";
// flush string stream buffer with new line
std::cout << "I flushed it away" << std::endl;
}
//////////
@ -218,22 +222,20 @@ int main()
// Strings in C++ are objects and have many member functions
#include <string>
using namespace std; // Strings are also in the namespace std (standard library)
string myString = "Hello";
string myOtherString = " World";
std::string myString = "Hello";
std::string myOtherString = " World";
// + is used for concatenation.
cout << myString + myOtherString; // "Hello World"
std::cout << myString + myOtherString; // "Hello World"
cout << myString + " You"; // "Hello You"
std::cout << myString + " You"; // "Hello You"
// C++ string length can be found from either string::length() or string::size()
cout << myString.length() + myOtherString.size(); // Outputs 11 (= 5 + 6).
// C++ strings are mutable.
myString.append(" Dog");
cout << myString; // "Hello Dog"
std::cout << myString; // "Hello Dog"
// C++ can handle C-style strings with related functions using cstrings
#include <cstring>
@ -254,35 +256,32 @@ cout << "Length = " << strlen(myOldString); // Length = 9
// No * is needed for dereferencing and
// & (address of) is not used for assignment.
using namespace std;
std::string foo = "I am foo";
std::string bar = "I am bar";
string foo = "I am foo";
string bar = "I am bar";
string& fooRef = foo; // This creates a reference to foo.
std::string& fooRef = foo; // This creates a reference to foo.
fooRef += ". Hi!"; // Modifies foo through the reference
cout << fooRef; // Prints "I am foo. Hi!"
std::cout << fooRef; // Prints "I am foo. Hi!"
// Doesn't reassign "fooRef". This is the same as "foo = bar", and
// foo == "I am bar"
// after this line.
cout << &fooRef << endl; //Prints the address of foo
std::cout << &fooRef << '\n'; // Prints the address of foo
fooRef = bar;
cout << &fooRef << endl; //Still prints the address of foo
cout << fooRef; // Prints "I am bar"
std::cout << &fooRef << '\n'; // Still prints the address of foo
std::cout << fooRef << '\n'; // Prints "I am bar"
// The address of fooRef remains the same, i.e. it is still referring to foo.
const string& barRef = bar; // Create a const reference to bar.
const std::string& barRef = bar; // Create a const reference to bar.
// Like C, const values (and pointers and references) cannot be modified.
barRef += ". Hi!"; // Error, const references cannot be modified.
// Sidetrack: Before we talk more about references, we must introduce a concept
// called a temporary object. Suppose we have the following code:
string tempObjectFun() { ... }
string retVal = tempObjectFun();
std::string tempObjectFun() { ... }
std::string retVal = tempObjectFun();
// What happens in the second line is actually:
// - a string object is returned from tempObjectFun
@ -307,7 +306,7 @@ foo(bar(tempObjectFun()))
void constReferenceTempObjectFun() {
// constRef gets the temporary object, and it is valid until the end of this
// function.
const string& constRef = tempObjectFun();
const std::string& constRef = tempObjectFun();
...
}
@ -315,17 +314,17 @@ void constReferenceTempObjectFun() {
// objects. You cannot have a variable of its type, but it takes precedence in
// overload resolution:
void someFun(string& s) { ... } // Regular reference
void someFun(string&& s) { ... } // Reference to temporary object
void someFun(std::string& s) { ... } // Regular reference
void someFun(std::string&& s) { ... } // Reference to temporary object
string foo;
std::string foo;
someFun(foo); // Calls the version with regular reference
someFun(tempObjectFun()); // Calls the version with temporary reference
// For example, you will see these two versions of constructors for
// std::basic_string:
basic_string(const basic_string& other);
basic_string(basic_string&& other);
std::basic_string(const basic_string& other);
std::basic_string(basic_string&& other);
// Idea being if we are constructing a new string from a temporary object (which
// is going to be destroyed soon anyway), we can have a more efficient
@ -586,7 +585,7 @@ int main () {
// Point up calls the + (function) with right as its parameter
Point result = up + right;
// Prints "Result is upright (1,1)"
cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
std::cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
return 0;
}
@ -654,7 +653,7 @@ barkThreeTimes(fluffy); // Prints "Fluffy barks" three times.
// Template parameters don't have to be classes:
template<int Y>
void printMessage() {
cout << "Learn C++ in " << Y << " minutes!" << endl;
std::cout << "Learn C++ in " << Y << " minutes!\n";
}
// And you can explicitly specialize templates for more efficient code. Of
@ -663,7 +662,7 @@ void printMessage() {
// even if you explicitly specified all parameters.
template<>
void printMessage<10>() {
cout << "Learn C++ faster in only 10 minutes!" << endl;
std::cout << "Learn C++ faster in only 10 minutes!\n";
}
printMessage<20>(); // Prints "Learn C++ in 20 minutes!"
@ -716,6 +715,9 @@ void doSomethingWithAFile(const char* filename)
// To begin with, assume nothing can fail.
FILE* fh = fopen(filename, "r"); // Open the file in read mode.
if (fh == NULL) {
// Handle possible error
}
doSomethingWithTheFile(fh);
doSomethingElseWithIt(fh);
@ -855,9 +857,9 @@ delete ptr;
// Usage of "std::shared_ptr":
void foo()
{
// It's no longer necessary to delete the Dog.
std::shared_ptr<Dog> doggo(new Dog());
doggo->bark();
// It's no longer necessary to delete the Dog.
std::shared_ptr<Dog> doggo(new Dog());
doggo->bark();
}
// Beware of possible circular references!!!
@ -893,22 +895,23 @@ doggo_two = doggo_one; // p2 references p1
// Vector (Dynamic array)
// Allow us to Define the Array or list of objects at run time
#include <vector>
string val;
vector<string> my_vector; // initialize the vector
cin >> val;
std::string val;
std::vector<string> my_vector; // initialize the vector
std::cin >> val;
my_vector.push_back(val); // will push the value of 'val' into vector ("array") my_vector
my_vector.push_back(val); // will push the value into the vector again (now having two elements)
// To iterate through a vector we have 2 choices:
// Either classic looping (iterating through the vector from index 0 to its last index):
for (int i = 0; i < my_vector.size(); i++) {
cout << my_vector[i] << endl; // for accessing a vector's element we can use the operator []
std::cout << my_vector[i] << '\n'; // for accessing a vector's element we can use the operator []
}
// or using an iterator:
vector<string>::iterator it; // initialize the iterator for vector
for (it = my_vector.begin(); it != my_vector.end(); ++it) {
cout << *it << endl;
std::cout << *it << '\n';
}
// Set
@ -917,7 +920,7 @@ for (it = my_vector.begin(); it != my_vector.end(); ++it) {
// without any other functions or code.
#include<set>
set<int> ST; // Will initialize the set of int data type
std::set<int> ST; // Will initialize the set of int data type
ST.insert(30); // Will insert the value 30 in set ST
ST.insert(10); // Will insert the value 10 in set ST
ST.insert(20); // Will insert the value 20 in set ST
@ -929,9 +932,9 @@ ST.insert(30); // Will insert the value 30 in set ST
ST.erase(20); // Will erase element with value 20
// Set ST: 10 30
// To iterate through Set we use iterators
set<int>::iterator it;
for(it=ST.begin();it!=ST.end();it++) {
cout << *it << endl;
std::set<int>::iterator it;
for(it = ST.begin(); it != ST.end(); it++) {
std::cout << *it << '\n';
}
// Output:
// 10
@ -939,7 +942,7 @@ for(it=ST.begin();it!=ST.end();it++) {
// To clear the complete container we use Container_name.clear()
ST.clear();
cout << ST.size(); // will print the size of set ST
std::cout << ST.size(); // will print the size of set ST
// Output: 0
// NOTE: for duplicate elements we can use multiset
@ -951,7 +954,7 @@ cout << ST.size(); // will print the size of set ST
// and a mapped value, following a specific order.
#include<map>
map<char, int> mymap; // Will initialize the map with key as char and value as int
std::map<char, int> mymap; // Will initialize the map with key as char and value as int
mymap.insert(pair<char,int>('A',1));
// Will insert value 1 for key A
@ -959,16 +962,16 @@ mymap.insert(pair<char,int>('Z',26));
// Will insert value 26 for key Z
// To iterate
map<char,int>::iterator it;
std::map<char,int>::iterator it;
for (it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << "->" << it->second << std::endl;
std::cout << it->first << "->" << it->second << '\n';
// Output:
// A->1
// Z->26
// To find the value corresponding to a key
it = mymap.find('Z');
cout << it->second;
std::cout << it->second;
// Output: 26
@ -1006,7 +1009,7 @@ fooMap.find(Foo(1)); //true
// For example, consider sorting a vector of pairs using the second
// value of the pair
vector<pair<int, int> > tester;
std::vector<pair<int, int> > tester;
tester.push_back(make_pair(3, 6));
tester.push_back(make_pair(1, 9));
tester.push_back(make_pair(5, 0));
@ -1014,7 +1017,7 @@ tester.push_back(make_pair(5, 0));
// Pass a lambda expression as third argument to the sort function
// sort is from the <algorithm> header
sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
std::sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second < rhs.second;
});
@ -1028,7 +1031,7 @@ sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int,
// 4. same as 3, but by value [=]
// Example:
vector<int> dog_ids;
std::vector<int> dog_ids;
// number_of_dogs = 3;
for(int i = 0; i < 3; i++) {
dog_ids.push_back(i);
@ -1133,33 +1136,33 @@ const int maxL = 15;
auto second = make_tuple(maxN, maxL);
// Printing elements of 'first' tuple
cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A
std::cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A
// Printing elements of 'second' tuple
cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15
std::cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15
// Unpacking tuple into variables
int first_int;
char first_char;
tie(first_int, first_char) = first;
cout << first_int << " " << first_char << '\n'; // prints : 10 A
std::cout << first_int << " " << first_char << '\n'; // prints : 10 A
// We can also create tuple like this.
tuple<int, char, double> third(11, 'A', 3.14141);
// tuple_size returns number of elements in a tuple (as a constexpr)
cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3
std::cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3
// tuple_cat concatenates the elements of all the tuples in the same order.
auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A', 3.14141)
cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'
std::cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
std::cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
std::cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'
///////////////////////////////////
@ -1207,7 +1210,7 @@ compl 4 // Performs a bitwise not
4 xor 3 // Performs bitwise xor
```
Further Reading:
## Further Reading:
* An up-to-date language reference can be found at [CPP Reference](http://cppreference.com/w/cpp).
* A tutorial for beginners or experts, covering many modern features and good practices: [LearnCpp.com](https://www.learncpp.com/)