WWW.APPSERVGRID.COM https://www.art2dec.co/fort/ |
|
C++ Language Tutorial, Part 4. June 2018 https://www.art2dec.co/fort/viewtopic.php?f=23&t=7420 |
Page 1 of 1 |
Author: | admin [ Mon Feb 11, 2019 3:10 am ] |
Post subject: | C++ Language Tutorial, Part 4. June 2018 |
Class Templates Just as we can define function templates, we can also define class templates, allowing classes to have members that use template parameters as types. The same syntax is used to define the class template: template <class T> class MyClass { }; Just as with function templates, you can define more than one generic data type by using a comma-separated list. --------------------------------------------------------------------------------------------------------------------- Class Templates As an example, let's create a class Pair, that will be holding a pair of values of a generic type. template <class T> class Pair { private: T first, second; public: Pair (T a, T b): first(a), second(b) { } }; The code above declares a class template Pair, with two private variables of a generic type, and one constructor to initialize the variables. --------------------------------------------------------------------------------------------------------------------- Class Templates A specific syntax is required in case you define your member functions outside of your class - for example in a separate source file. You need to specify the generic type in angle brackets after the class name. For example, to have a member function bigger() defined outside of the class, the following syntax is used: template <class T> class Pair { private: T first, second; public: Pair (T a, T b): first(a), second(b){ } T bigger(); }; template <class T> T Pair<T>::bigger() { // some code } ------------------------------------------------------------------------------------------------------------------------- Fill in the blanks to define a ''MyClass'' member function ''hello()'', where ''MyClass'' is a template class, and ''hello()'' prints ''Hi'' to the screen. template <class T> void MyClass<T> ::hello() { cout << "Hi" << endl; } ------------------------------------------------------------------------------------------------------------------------ Class Templates The bigger function returns the greater value of the two member variables. template <class T> class Pair { private: T first, second; public: Pair (T a, T b): first(a), second(b){ } T bigger(); }; template <class T> T Pair<T>::bigger() { return (first>second ? first : second); } The ternary operator compares the two variables, returning the greater one. ------------------------------------------------------------------------------------------------------------------------ Class Templates To create objects of the template class for different types, specify the data type in angle brackets, as we did when defining the function outside of the class. Here, we create a Pair object for integers. Pair <int> obj(11, 22); cout << obj.bigger(); // Outputs 22 We can use the same class to create an object that stores any other type. Pair <double> obj(23.43, 5.68); cout << obj.bigger(); // Outputs 23.43 ------------------------------------------------------------------------------------------------------------------------- Template Specialization In case of regular class templates, the way the class handles different data types is the same; the same code runs for all data types. Template specialization allows for the definition of a different implementation of a template when a specific type is passed as a template argument. For example, we might need to handle the character data type in a different manner than we do numeric data types. To demonstrate how this works, we can first create a regular template. template <class T> class MyClass { public: MyClass (T x) { cout <<x<<" - not a char"<<endl; } }; As a regular class template, MyClass treats all of the various data types in the same way. ------------------------------------------------------------------------------------------------------------------------- Fill in the blanks to declare a class template ''Spunky''. template <class T> class Spunky { public: Spunky(T x) { cout << x << " is not a character" << endl; } }; -------------------------------------------------------------------------------------------------------------------------- Template Specialization To specify different behavior for the data type char, we would create a template specialization. template <class T> class MyClass { public: MyClass (T x) { cout <<x<<" - not a char"<<endl; } }; template < > class MyClass<char> { public: MyClass (char x) { cout <<x<<" is a char!"<<endl; } }; First of all, notice that we precede the class name with template<>, including an empty parameter list. This is because all types are known and no template arguments are required for this specialization, but still, it is the specialization of a class template, and thus it requires to be noted as such. But more important than this prefix, is the <char> specialization parameter after the class template name. This specialization parameter itself identifies the type for which the template class is being specialized (char). In the example above, the first class is the generic template, while the second is the specialization. If necessary, your specialization can indicate a completely different behavior from the behavior of your the generic template. -------------------------------------------------------------------------------------------------------------------------- Fill in the blanks to specialize the ''Spunky'' template class for the characters. template <> class Spunky <char> {public: Spunky(char x) { cout << x << "is a char" << endl; } }; --------------------------------------------------------------------------------------------------------------------------- Template Specialization The next step is to declare objects of different types and check the result: int main () { MyClass<int> ob1(42); MyClass<double> ob2(5.47); MyClass<char> ob3('s'); } /* Output: 42 - not a char 5.47 - not a char s is a char! */ As you can see, the generic template worked for int and double. However, our template specialization was invoked for the char data type. Keep in mind that there is no member "inheritance" from the generic template to the specialization, so all members of the template class specializations must be defined on their own. ------------------------------------------------------------------------------------------------------------------------- Fill in the blanks to declare three objects of type ''Spunky'': i, d, ch, where i's template parameter is integer, d's template parameter is double and ch's is character. int main() { Spunky<int> i(4); Spunky<double> d(3.14); Spunky<char > ch('z'); } -------------------------------------------------------------------------------------------------------------------------- Exceptions Problems that occur during program execution are called exceptions. In C++ exceptions are responses to anomalies that arise while the program is running, such as an attempt to divide by zero. -------------------------------------------------------------------------------------------------------------------------- Throwing Exceptions C++ exception handling is built upon three keywords: try, catch, and throw. throw is used to throw an exception when a problem shows up. For example: int motherAge = 29; int sonAge = 36; if (sonAge > motherAge) { throw "Wrong age values"; } The code looks at sonAge and motherAge, and throws an exception if sonAge is found to be the greater of the two. In the throw statement, the operand determines a type for the exception. This can be any expression. The type of the expression's result will determine the type of the exception thrown. --------------------------------------------------------------------------------------------------------------------------- Catching Exceptions A try block identifies a block of code that will activate specific exceptions. It's followed by one or more catch blocks. The catch keyword represents a block of code that executes when a particular exception is thrown. Code that could generate an exception is surrounded with the try/catch block. You can specify what type of exception you want to catch by the exception declaration that appears in parentheses following the keyword catch. For example: try { int motherAge = 29; int sonAge = 36; if (sonAge > motherAge) { throw 99; } } catch (int x) { cout<<"Wrong age values - Error "<<x; } //Outputs "Wrong age values - Error 99" The try block throws the exception, and the catch block then handles it. The error code 99, which is an integer, appears in the throw statement, so it results in an exception of type int. Multiple catch statements may be listed to handle various exceptions in case multiple exceptions are thrown by the try block. -------------------------------------------------------------------------------------------------------------------------- Fill in the blanks to define a function ''foo'', which throws an exception with ''-1'' value if its parameter is greater than 100. Then have ''foo'' catch its exception and prints ''error!'' to the screen. void foo(int arg) { try { if (arg > 100) throw -1; } catch (int x) { cout << "error!" << endl; } } --------------------------------------------------------------------------------------------------------------------------- Exception Handling Exception handling is particularly useful when dealing with user input. For example, for a program that requests user input of two numbers, and then outputs their division, be sure that you handle division by zero, in case your user enters 0 as the second number. int main() { int num1; cout <<"Enter the first number:"; cin >> num1; int num2; cout <<"Enter the second number:"; cin >> num2; cout <<"Result:"<<num1 / num2; } This program works perfectly if the user enters any number besides 0. In case of 0 the program crashes, so we need to handle that input. --------------------------------------------------------------------------------------------------------------------------- Exception Handling In the event that the second number is equal to 0, we need to throw an exception. int main() { int num1; cout <<"Enter the first number:"; cin >> num1; int num2; cout <<"Enter the second number:"; cin >> num2; if(num2 == 0) { throw 0; } cout <<"Result:"<<num1 / num2; } This code throws an exception with the code 0 of type integer. Next stop: Using the try/catch block to handle the exception! ----------------------------------------------------------------------------------------------- Exception Handling Now we need to handle the thrown exception using a try/catch block. int main() { try { int num1; cout <<"Enter the first number:"; cin >> num1; int num2; cout <<"Enter the second number:"; cin >> num2; if(num2 == 0) { throw 0; } cout <<"Result:"<<num1 / num2; } catch(int x) { cout <<"Division by zero!"; } } This results in the output of "Division by zero!" as an alternative to a program crash, when 0 is entered as the second number. In our case, we catch exceptions of type integer only. It's possible to specify that your catch block handles any type of exception thrown in a try block. To accomplish this, add an ellipsis (...) between the parentheses of catch: try { // code } catch(...) { // code to handle exceptions } ------------------------------------------------------------------------------------------------ Working with Files Another useful C++ feature is the ability to read and write to files. That requires the standard C++ library called fstream. Three new data types are defined in fstream: ofstream: Output file stream that creates and writes information to files. ifstream: Input file stream that reads information from files. fstream: General file stream, with both ofstream and ifstream capabilities that allow it to create, read, and write information to files. To perform file processing in C++, header files <iostream> and <fstream> must be included in the C++ source file. #include <iostream> #include <fstream> --------------------------------------------------------------------------------------------------- Opening a File A file must be opened before you can read from it or write to it. Either the ofstream or fstream object may be used to open a file for writing. Let's open a file called "test.txt" and write some content to it: #include <iostream> #include <fstream> using namespace std; int main() { ofstream MyFile; MyFile.open("test.txt"); MyFile << "Some text. \n"; } The above code creates an ofstream object called MyFile, and uses the open() function to open the "test.txt" file on the file system. As you can see, the same stream output operator is used to write into the file. If the specified file does not exist, the open function will create it automatically. ---------------------------------------------------------------------------------------------------- Closing a File When you've finished working with a file, close it using the member function close(). #include <iostream> #include <fstream> using namespace std; int main() { ofstream MyFile; MyFile.open("test.txt"); MyFile << "Some text! \n"; MyFile.close(); } Running this code will cause a "test.txt" file to be created in the directory of your project with "Some text!" written in it. You also have the option of specifying a path for your file in the open function, since it can be in a location other than that of your project. ----------------------------------------------------------------------------------------------------- Working with Files You can also provide the path to your file using the ofstream objects constructor, instead of calling the open function. #include <fstream> using namespace std; int main() { ofstream MyFile("test.txt"); MyFile << "This is awesome! \n"; MyFile.close(); } As with the open function, you can provide a full path to your file located in a different directory. ------------------------------------------------------------------------------------------------------- Working with Files Under certain circumstances, such as when you don't have file permissions, the open function can fail. The is_open() member function checks whether the file is open and ready to be accessed. #include <iostream> #include <fstream> using namespace std; int main() { ofstream MyFile("test.txt"); if (MyFile.is_open()) { MyFile << "This is awesome! \n"; } else { cout << "Something went wrong"; } MyFile.close(); } -------------------------------------------------------------------------------------------------------- File Opening Modes An optional second parameter of the open function defines the mode in which the file is opened. All these flags can be combined using the bitwise operator OR (|). For example, to open a file in write mode and truncate it, in case it already exists, use the following syntax: ofstream outfile; outfile.open("file.dat", ios::out | ios::trunc ); Reading from a File You can read information from a file using an ifstream or fstream object. #include <iostream> #include <fstream> using namespace std; int main () { string line; ifstream MyFile("test.txt"); while ( getline (MyFile, line) ) { cout << line << '\n'; } MyFile.close(); } The getline function reads characters from an input stream and places them into a string. The example above reads a text file and prints the contents to the screen. Our while loop uses the getline function to read the file line by line. ---------------------------------------------------------------------------------------------------------- Fill in the blanks to declare a template class ''MyClass'' with two template data members: ''first'' and ''second''. Initialize them in the constructor. template <class T> class MyClass { T first; T second; public: MyClass(T a, T b) { first = a; second = b; } }; --------------------------------------------------------------------------------------------- Fill in the blanks to declare a class "test" with a "foo()" public member function. Declare a pointer "myPtr" to "test" and call "foo()" via the pointer. class test{ public: void foo() { } }; test* myPtr = new test(); myPtr -> foo(); ----------------------------------------------------------------------------------- |
Page 1 of 1 | All times are UTC + 2 hours [ DST ] |
Powered by phpBB® Forum Software © phpBB Group http://www.phpbb.com/ |