本 Wiki 开启了 HTTPS。但由于同 IP 的 Blog 也开启了 HTTPS，因此本站必须要支持 SNI 的浏览器才能浏览。为了兼容一部分浏览器，本站保留了 HTTP 作为兼容。如果您的浏览器支持 SNI，请尽量通过 HTTPS 访问本站，谢谢！
这里会显示出您选择的修订版和当前版本之间的差别。
| 两侧同时换到之前的修订记录前一修订版后一修订版 | 前一修订版 | ||
| cs:programming:cpp:cpp_primer:answers:chpt_6 [2024/01/14 13:46] – 移除 - 外部编辑 (未知日期) 127.0.0.1 | cs:programming:cpp:cpp_primer:answers:chpt_6 [2024/03/08 05:59] (当前版本) – [ex.6.6] codinghare | ||
|---|---|---|---|
| 行 1: | 行 1: | ||
| + | ======Chapter.6====== | ||
| + | 第六章的习题答案 | ||
| + | ---- | ||
| + | ====Ex.6.1-6.10==== | ||
| + | ==ex.6.1== | ||
| + | > | ||
| + | A parameter is a local variable, a part of a function. It receives an argument as an initializer. An argument is a value that is being supplied to initialize the parameter when calling a function. | ||
| + | ==ex.6.2== | ||
| + | > | ||
| + | <code cpp> | ||
| + | (a) int f() { | ||
| + | string s; | ||
| + | // ... | ||
| + | return s; //The return type of the function is int, but it returns a string value. | ||
| + | } | ||
| + | Fix: | ||
| + | string f() { | ||
| + | string s; | ||
| + | // ... | ||
| + | return s; | ||
| + | } | ||
| + | (b) f2(int i) { /* ... */ } //The function has no return type. | ||
| + | Fix: | ||
| + | void f2 (int i) { /* ... */ } | ||
| + | |||
| + | (c) int calc(int v1, int v1) /* ... */ } //Duplicate name in parameters. | ||
| + | Fix: | ||
| + | int calc(int v1, int v2) /* ... */ } | ||
| + | |||
| + | (d) double square(double x) return x * x; //The function needs a pair of curly brace to claim its scope. | ||
| + | Fix: | ||
| + | double square(double x) {return x * x}; | ||
| + | </ | ||
| + | |||
| + | ==ex.6.3== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cin; | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | int fact(unsigned int n) { | ||
| + | int ret{1}; | ||
| + | for (; n > 0;) { | ||
| + | ret *= n--; | ||
| + | } | ||
| + | return ret; | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | unsigned int fact_num {5}; | ||
| + | cout << fact(fact_num) << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.4== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cin; | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | int fact(unsigned int n) { | ||
| + | int ret{1}; | ||
| + | for (; n > 0;) { | ||
| + | ret *= n--; | ||
| + | } | ||
| + | return ret; | ||
| + | } | ||
| + | |||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | unsigned int fact_num {0}; | ||
| + | cin >> fact_num; | ||
| + | cout << fact(fact_num) << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.5== | ||
| + | > | ||
| + | <code cpp> | ||
| + | int my_abs (int i) { | ||
| + | return i >= 0 ? i : -i; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.6== | ||
| + | > | ||
| + | |||
| + | * Local Variable: A local variable is initialized by an argument or a initializer that is created inside a function. It will be destroyed when a function block ends. | ||
| + | * Parameter: A parameter is a local variable that is initialized by an argument. | ||
| + | * Local static Variable: A local static variable is defined inside the function, initialized when a function starts to run, and would last across multiple function calls, until the final call of the function. | ||
| + | <code cpp> | ||
| + | int add_and_count (unsinged int num) { //num is a parameter. | ||
| + | static unsinged int count {0}; //count is a local static variable that counts how many times the function runs. | ||
| + | int i {1}; // i is a local variable for adding purpose. | ||
| + | cout << "The " << num <<" | ||
| + | cout << "The function runs " << count << " times." | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | add_and_count(1); | ||
| + | add_and_count(2); | ||
| + | add_and_count(3); | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.7== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | int count_ret () { | ||
| + | static unsigned int count {0}; | ||
| + | return ++count; | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | for (int i = 0; i < 5; ++i) | ||
| + | cout << count_ret() << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.8== | ||
| + | > | ||
| + | <code cpp># | ||
| + | #define CHAPTER6_H | ||
| + | int fact(unsigned int n); //function in ex.6.3 | ||
| + | int my_abs(int i); //function in ex.6.5 | ||
| + | #endif | ||
| + | </ | ||
| + | ==ex.6.9== | ||
| + | > | ||
| + | CODE: | ||
| + | [[https:// | ||
| + | [[https:// | ||
| + | [[https:// | ||
| + | ==ex.6.10== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cin; | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | void swap_int(int *pi, int *pj) { | ||
| + | int temp = *pi; | ||
| + | *pi = *pj; | ||
| + | *pj = temp; | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | int i{0},j{0}; | ||
| + | cin >> i >> j; | ||
| + | swap_int(& | ||
| + | cout << i << " " << j << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ====Ex.6.11-6.20==== | ||
| + | ==ex.6.11== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cin; | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | void reset(int& | ||
| + | ri = 0; | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | int i{0}; | ||
| + | |||
| + | while (cin >> i) { | ||
| + | reset(i); | ||
| + | cout << i << endl; | ||
| + | } | ||
| + | |||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.12== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | using std::cin; | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | void swap_intr (int& a, int& b) { | ||
| + | int temp = a; | ||
| + | a = b; | ||
| + | b = temp; | ||
| + | } | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | int i{0},j{0}; | ||
| + | cin >> i >> j; | ||
| + | swap_intr(i, | ||
| + | cout << i << " " << j << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | In this case, the passing reference method is taking advantage. Since passing a pointer is actually copying the pointer where stored in argument to the parameter, the value which is pointed by the parameter may be changed through the pointer in argument potentially. The operation could be avoided by using the passed-by-reference method. | ||
| + | ==ex.6.13== | ||
| + | > | ||
| + | |||
| + | * The first form: the parameter is a copy of the argument, changing the value of the parameter doesn' | ||
| + | * The second form: while calling the function, a reference is bound to the argument and passed to the function. Any modification to the reference affects the argument. | ||
| + | ==ex.6.14== | ||
| + | > | ||
| + | using reference when you intend to change a argument in the a function: | ||
| + | <code cpp> | ||
| + | void reset(int& | ||
| + | ri = 0; | ||
| + | } | ||
| + | </ | ||
| + | using reference when the argument is large: | ||
| + | <code cpp> | ||
| + | bool is_shorter(const string &s1, const string &s2) { | ||
| + | return s1.size() < s2.size(); | ||
| + | } | ||
| + | </ | ||
| + | using reference when passing class, for example, '' | ||
| + | <code cpp> | ||
| + | void print(std:: | ||
| + | </ | ||
| + | |||
| + | using passed-by-value method when you don't want the changing of the parameter affect the argument: | ||
| + | <code cpp> | ||
| + | int fact(unsigned int n) { | ||
| + | int ret{1}; | ||
| + | for (; n > 0;) { | ||
| + | ret *= n--; | ||
| + | } | ||
| + | return ret; | ||
| + | } | ||
| + | </ | ||
| + | using passed-by-value method when you have to use pointer: | ||
| + | <code cpp> | ||
| + | void generateArray(int *a, int si) | ||
| + | { | ||
| + | for (int j = 0; j < si; j++) | ||
| + | a[j] = rand() % 9; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.15== | ||
| + | > | ||
| + | //**Why is s a reference to const?**// \\ \\ | ||
| + | When passing a large object, using reference to avoid copies, which could save memory and time,is considered as a performance improvement. Since we don't want to change any | ||
| + | thing of the string '' | ||
| + | //**But occurs is a plain reference? | ||
| + | '' | ||
| + | //**Why are these parameters references, but the char parameter c is not?**//\\ \\ | ||
| + | In the program, char '' | ||
| + | //**What would happen if we made s a plain reference? | ||
| + | Since there is no modification related to string '' | ||
| + | //**What if we made occurs a reference to const?**// \\ \\ | ||
| + | The program won't compile since we are trying to update a value through a reference-to-const. | ||
| + | ==Ex.6.16== | ||
| + | > | ||
| + | <code cpp> | ||
| + | bool is_empty(string& | ||
| + | </ | ||
| + | The function is trying to check if a string is empty. In this case, it is not necessary to change the content of the string. A reference to a const string type parameter should be applied here. | ||
| + | <code cpp> | ||
| + | bool is_empty(const string& s) { return s.empty(); } | ||
| + | </ | ||
| + | > | ||
| + | No. the first function should have a read-only string parameter since the function does nothing to do with the string. The second function needs a plain reference to string type parameters because the string needs modification permission to perform lowercasing for the letters. \\ \\ | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.18== | ||
| + | >Write declarations for each of the following functions. When you write these declarations, | ||
| + | *// (a) A function named compare that returns a bool and has two parameters that are references to a class named matrix.// | ||
| + | <code cpp> | ||
| + | bool compare (const matrix& a, const matrix& b) {/* .. */}; | ||
| + | </ | ||
| + | * //(b) A function named change_val that returns a vector< | ||
| + | <code cpp> | ||
| + | vector< | ||
| + | </ | ||
| + | ==ex.6.19== | ||
| + | > | ||
| + | <code cpp> | ||
| + | double calc(double); | ||
| + | int count(const string &, char); | ||
| + | int sum(vector< | ||
| + | vector< | ||
| + | (a) calc(23.4, 55.1); //illegal. cale() only needs 1 argument | ||
| + | (b) count(" | ||
| + | (c) calc(66); //legal | ||
| + | (d) sum(vec.begin(), | ||
| + | </ | ||
| + | ==ex.6.20== | ||
| + | > | ||
| + | **//When should reference parameters be references to const?// | ||
| + | * if you don't want to change the parameter | ||
| + | * if passing a large argument | ||
| + | * if modifying of argument is demanded | ||
| + | **//What happens if we make a parameter a plain reference when it could be a reference to const?//** | ||
| + | * The input range is narrowed: the function can't accept a low-level const parameter anymore. | ||
| + | * Callers are misled: they thought they might modify the parameter, which is against your intention. | ||
| + | ====Ex.6.21-6.30==== | ||
| + | ==ex.6.21== | ||
| + | > | ||
| + | <code cpp> | ||
| + | int int_comp(const int i, const int* const pi) { | ||
| + | return i > *pi ? i : *pi; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.22== | ||
| + | > | ||
| + | <code cpp> | ||
| + | void swap_ptr (const int* &pi, const int* &pj) { | ||
| + | const int *temp = pi; | ||
| + | pi = pj; | ||
| + | pj = temp; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.23== | ||
| + | > | ||
| + | <code cpp> | ||
| + | int i = 0, j[2] = {0, 1}; | ||
| + | </ | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.24== | ||
| + | > | ||
| + | <code cpp> | ||
| + | void print(const int ia[10]) | ||
| + | { | ||
| + | for (size_t i = 0; i != 10; ++i) | ||
| + | cout << ia[i] << endl; | ||
| + | } | ||
| + | </ | ||
| + | The function is working. However, it just looks like the function received the size of the array. The parameter only passed its name; The real thing that matters the loop is the variable '' | ||
| + | |||
| + | The way to pass the size of an array to a function is by using the reference of the array. a size of an array is part of the definition of the reference of the array. When passing, the function checks if the argument size matches the size in the definition. | ||
| + | **Fix:** | ||
| + | <code cpp> | ||
| + | void print(const int (&ia) [10]) | ||
| + | { | ||
| + | for (size_t i = 0; i != 10; ++i) | ||
| + | cout << ia[i] << endl; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.25== | ||
| + | > | ||
| + | <code cpp> | ||
| + | #include < | ||
| + | #include < | ||
| + | using std:: | ||
| + | using std::cout; | ||
| + | using std::endl; | ||
| + | |||
| + | int main(int argc, char const *argv[]) | ||
| + | { | ||
| + | string str {"" | ||
| + | for(int i = 0; i != argc; ++i) | ||
| + | str += argv[i]; | ||
| + | cout << "The concatenated string is: "; | ||
| + | cout << str << endl; | ||
| + | return 0; | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.26== | ||
| + | > | ||
| + | Please refer to ex.6.25 for the source code. CLI commands: | ||
| + | <code bash> | ||
| + | #command | ||
| + | root@Hare:/ | ||
| + | #output | ||
| + | The concatenated string is: ./ | ||
| + | </ | ||
| + | ==ex.6.27== | ||
| + | > | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.28== | ||
| + | > | ||
| + | const string. | ||
| + | ==ex.6.29== | ||
| + | > | ||
| + | Not for small-type elements. because elements of an initializer_list are all const variables. However, elements as large as a string should use a reference instead. | ||
| + | ==ex.6.30== | ||
| + | > | ||
| + | <code bash> | ||
| + | # g++ | ||
| + | |||
| + | #error 1 | ||
| + | root@Hare:/ | ||
| + | test.cc: In function ‘const string& ret_str()’: | ||
| + | test.cc: | ||
| + | | ||
| + | | ||
| + | #error 2 | ||
| + | root@Hare:/ | ||
| + | test.cc: In function ‘const string& ret_str()’: | ||
| + | test.cc: | ||
| + | std::string s = "Hello world"; | ||
| + | </ | ||
| + | ====Ex.6.31-6.40==== | ||
| + | ==ex.6.31== | ||
| + | > | ||
| + | **//When is it valid to return a reference?// | ||
| + | As long as the reference is not refering to a local variable, it is valid to return it.\\ \\ | ||
| + | **//A reference to const?//** \\ \\ | ||
| + | Since a non-const object can initialize a low-const variable, return a vaild reference to const has the same requirement as the plain one. | ||
| + | ==ex.6.32== | ||
| + | > | ||
| + | <code cpp> | ||
| + | int & | ||
| + | int main() { | ||
| + | int ia[10]; | ||
| + | for (int i = 0; i != 10; ++i) | ||
| + | get(ia, i) = i; | ||
| + | } | ||
| + | </ | ||
| + | legal. The program is about write '' | ||
| + | ==ex.6.33== | ||
| + | > | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.34== | ||
| + | > | ||
| + | Assuming we don’t have negative input (because factorial is not available for negative numbers). The problem is when '' | ||
| + | PS: the $0!$ is actually $1$! | ||
| + | ==ex.6.35== | ||
| + | > | ||
| + | '' | ||
| + | ==ex.6.36== | ||
| + | > | ||
| + | <code cpp> | ||
| + | std::string (& | ||
| + | </ | ||
| + | ==ex.6.37== | ||
| + | Exercise 6.37: Write three additional declarations for the function in the previous exercise. One should use a type alias, one should use a trailing return, and the third should use decltype. Which form do you prefer and why? | ||
| + | <code cpp> | ||
| + | //alias | ||
| + | using s_ten_r = string (& | ||
| + | s_ten_r arrT1(); | ||
| + | //trail return type | ||
| + | auto arrT2() -> string (& | ||
| + | //decltype | ||
| + | string sa[10] = {"","","","","","","","","","" | ||
| + | decltype(sa) & | ||
| + | </ | ||
| + | I preferred the trail return type form. it is more esaier to understand and write. | ||
| + | ==ex.6.38== | ||
| + | > | ||
| + | <code cpp> | ||
| + | decltype(odd)& | ||
| + | return (i % 2) ? &odd : & | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.39== | ||
| + | Exercise 6.39: Explain the effect of the second declaration in each one of the following sets of declarations. Indicate which, if any, are illegal. | ||
| + | <code cpp> | ||
| + | //They are the same function since the top-const is ignored when initializing. Can't complie. | ||
| + | (a) int calc(int, int); | ||
| + | int calc(const int, const int); | ||
| + | |||
| + | //They are the same function. The return type of the function doesn' | ||
| + | (b) int get(); | ||
| + | double get(); | ||
| + | |||
| + | //They are different functions because they have different types of parameters. Can complie. | ||
| + | (c) int *reset(int *); | ||
| + | double *reset(double *); | ||
| + | </ | ||
| + | ==ex.6.40== | ||
| + | > | ||
| + | <code cpp> | ||
| + | (a) int ff(int a, int b = 0, int c = 0); //legal | ||
| + | (b) char *init(int ht = 24, int wd, char bckgrnd);// | ||
| + | </ | ||
| + | ====Ex.6.41-6.50==== | ||
| + | ==ex.6.41== | ||
| + | > | ||
| + | <code cpp> | ||
| + | char *init(int ht, int wd = 80, char bckgrnd = ' '); | ||
| + | (a) init(); //illegal, ht has no default arugment. | ||
| + | (b) init(24, | ||
| + | (c) init(14, ' | ||
| + | </ | ||
| + | ==ex.6.42== | ||
| + | > | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.43== | ||
| + | > | ||
| + | <code cpp> (a) inline bool eq(const BigInt&, | ||
| + | Inline functions may be defined more than once, as they are inline functions. Therefore, this function should be in a header. Including an inline function in a header makes sharing it easier.\\ \\ | ||
| + | <code cpp>(b) void putValues(int *arr, int size);</ | ||
| + | The function should also be put in a header since it does not come with a definition. A common way to share a function is to define it in a source file (the header file that declares the function may also be included in the source file), declare it in a header file, and then use it by including the header. | ||
| + | ==ex.6.44== | ||
| + | > | ||
| + | <code cpp> | ||
| + | inline bool | ||
| + | isShorter(const string &s1, const string &s2) { | ||
| + | return s1.size() < s2.size(); | ||
| + | } | ||
| + | </ | ||
| + | ==ex.6.45== | ||
| + | > | ||
| + | some functions that should be writed as an inline function: | ||
| + | <code cpp> | ||
| + | //get the absolute value of an int | ||
| + | int my_abs (int i) { return i >= 0 ? i : -i; }; | ||
| + | //compare two ints an return the large one | ||
| + | int int_comp(const int i, const int* const pi) { return i > *pi ? i : *pi; } | ||
| + | //adding plural ending | ||
| + | string make_plural (size_t ctr, cstr word, cstr ending = " | ||
| + | return (ctr > 1) ? word + ending : word; | ||
| + | } | ||
| + | </ | ||
| + | All of the functions above are written in a line and might be called multiple times. Therefore they should be written as inline functions. Some of them should not, however: | ||
| + | <code cpp> | ||
| + | //print an vector recursively | ||
| + | void print_vec(const it pbeg, const it pend) { | ||
| + | |||
| + | if (pend != pbeg + 1) | ||
| + | print_vec(pbeg , pend - 1); | ||
| + | cout << *(pend - 1) << " "; | ||
| + | } | ||
| + | </ | ||
| + | It is not ideal to inline functions that have multiple lines or complicated logic. | ||
| + | ==ex.6.46== | ||
| + | > | ||
| + | No. A constexpr function should have no rum-time actions, however, '' | ||
| + | ==ex.6.47== | ||
| + | > | ||
| + | |||
| + | When '' | ||
| + | <code bash> | ||
| + | root@Hare:/ | ||
| + | 1 2 3 4 5 6 7 8 9 10 | ||
| + | </ | ||
| + | When '' | ||
| + | <code bash> | ||
| + | root@Hare:/ | ||
| + | a.out: ex_6_47.cc: | ||
| + | </ | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.48== | ||
| + | > | ||
| + | <code cpp> | ||
| + | string s; | ||
| + | while (cin >> s && s != sought) { } // empty body | ||
| + | assert(cin); | ||
| + | </ | ||
| + | It is not a good use of '' | ||
| + | ==ex.6.49== | ||
| + | > | ||
| + | //**What is a candidate function? | ||
| + | >//Set of functions that are considered when resolving a function call. (all the functions with the name used in the call for which a declaration is in scope at the time of the call.)// | ||
| + | //**What is a viable function? | ||
| + | >// | ||
| + | ==ex.6.50== | ||
| + | > | ||
| + | <code cpp> | ||
| + | //a The call is an ambiguous call | ||
| + | f(2.56, 42); | ||
| + | |||
| + | //b | ||
| + | void f(int); //best match function | ||
| + | f(42) | ||
| + | |||
| + | //c | ||
| + | void f(int, int); //best match function | ||
| + | f(42, 0) | ||
| + | |||
| + | //d | ||
| + | void f(double, double = 3.14); //best match function | ||
| + | f(2.56, 3.14) | ||
| + | </ | ||
| + | ====Ex.6.51-6.56==== | ||
| + | ==ex.6.51== | ||
| + | > | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.52== | ||
| + | > | ||
| + | <code cpp> | ||
| + | void manip(int, int); | ||
| + | double dobj; | ||
| + | </ | ||
| + | <code cpp> | ||
| + | (a) manip(' | ||
| + | (b) manip(55.4, dobj);// rank 4, arithmetic conversion | ||
| + | </ | ||
| + | ==ex.6.53== | ||
| + | > | ||
| + | <code cpp> | ||
| + | (a) int calc(int&, | ||
| + | int calc(const int&, const int&); // a new function, takes reference to const | ||
| + | |||
| + | (b) int calc(char*, char*); | ||
| + | int calc(const char*, const char*); // a new function, takes pointer to const | ||
| + | |||
| + | (c) int calc(char*, char*); // take char* | ||
| + | int calc(char* const, char* const); // illegal, the same as the frist funcion, will cause ambiguous call | ||
| + | </ | ||
| + | ==ex.6.54== | ||
| + | > | ||
| + | <code cpp> | ||
| + | int func(int, int); //a function | ||
| + | int (*) (int, int); //the type of a poiner to the function | ||
| + | std:: | ||
| + | </ | ||
| + | ==ex.6.55== | ||
| + | > | ||
| + | CODE: [[https:// | ||
| + | ==ex.6.56== | ||
| + | > | ||
| + | See code in 6.55 | ||