CLASS

레슨 12: Introduction to Classes 2011.06.07
레슨 9: C Strings 2011.06.07

레슨 12: Introduction to Classes

잡초사랑 2011. 6. 7. 13:15

2011. 6. 7. 13:15

Lesson 12: Introduction to Classes

C++ is a bunch of small additions to C, with a few major additions. One major addition is the object-oriented approach (the other addition is support for *Generic programming, which we'll cover later). As the name object-oriented programming suggests, this approach deals with objects. Of course, these are not real-life objects themselves. Instead, these objects are the essential definitions of real world objects. Classes are collections of data related to a single object type. Classes not only include information regarding the real world object, but also functions to access the data, and classes possess the ability to inherit from other classes. (Inheritance is covered in a later lesson.)

If a class is a house, then the functions will be the doors and the variables will be the items inside the house. The functions usually will be the only way to modify the variables in this structure, and they are usually the only way even to access the variables in this structure. This might seem silly at first, but the idea to make programs more modular - the principle itself is called "encapsulation". The key idea is that the outside world doesn't need to know exactly what data is stored inside the class--it just needs to know which functions it can use to access that data. This allows the implementation to change more easily because nobody should have to rely on it except the class itself.

The syntax for these classes is simple. First, you put the keyword 'class' then the name of the class. Our example will use the name Computer. Then you put an open bracket. Before putting down the different variables, it is necessary to put the degree of restriction on the variable. There are three levels of restriction. The first is public, the second protected, and the third private. For now, all you need to know is that the public restriction allows any part of the program, including parts outside the class, to access the functions and variables specified as public. The protected restriction prevents functions outside the class to access the variable. The private restriction is similar to protected (we'll see the difference later when we look at inheritance. The syntax for declaring these access restrictions is merely the restriction keyword (public, private, protected) and then a colon. Finally, you put the different variables and functions (You usually will only put the function prototype[s]) you want to be part of the class. Then you put a closing bracket and semicolon. Keep in mind that you still must end the function prototype(s) with a semi-colon.

Let's look at these different access restrictions for a moment. Why would you want to declare something private instead of public? The idea is that some parts of the class are intended to be internal to the class--only for the purpose of implementing features. On the other hand, some parts of the class are supposed to be available to anyone using the class--these are the public class functions. Think of a class as though it were an appliance like a microwave: the public parts of the class correspond to the parts of the microwave that you can use on an everyday basis--the keypad, the start button, and so forth. On the other hand, some parts of the microwave are not easily accessible, but they are no less important--it would be hard to get at the microwave generator. These would correspond to the protected or private parts of the class--the things that are necessary for the class to function, but that nobody who uses the class should need to know about. The great thing about this separation is that it makes the class easier to use (who would want to use a microwave where you had to know exactly how it works in order to use it?) The key idea is to separate the interface you use from the way the interface is supported and implemented.

Classes must always contain two functions: a constructor and a destructor. The syntax for them is simple: the class name denotes a constructor, a ~ before the class name is a destructor. The basic idea is to have the constructor initialize variables, and to have the destructor clean up after the class, which includes freeing any memory allocated. If it turns out that you don't need to actually perform any initialization, then you can allow the compiler to create a "default constructor" for you. Similarly, if you don't need to do anything special in the destructor, the compiler can write it for you too!

When the programmer declares an instance of the class, the constructor will be automatically called. The only time the destructor is called is when the instance of the class is no longer needed--either when the program ends, the class reaches the end of scope, or when its memory is deallocated using delete (if you don't understand all of that, don't worry; the key idea is that destructors are always called when the class is no longer usable). Keep in mind that neither constructors nor destructors return arguments! This means you do not want to (and cannot) return a value in them.

Note that you generally want your constructor and destructor to be made public so that your class can be created! The constructor is called when an object is created, but if the constructor is private, it cannot be called so the object cannot be constructed. This will cause the compiler to complain.

The syntax for defining a function that is a member of a class outside of the actual class definition is to put the return type, then put the class name, two colons, and then the function name. This tells the compiler that the function is a member of that class.

For example:

 
#include <iostream>

using namespace std;

class Computer // Standard way of defining the class
{
public:
  // This means that all of the functions below this(and any variables)
  //  are accessible to the rest of the program.
  //  NOTE: That is a colon, NOT a semicolon...
  Computer();
  // Constructor
  ~Computer();
  // Destructor
  void setspeed ( int p );
  int readspeed();
protected:
  // This means that all the variables under this, until a new type of
  //  restriction is placed, will only be accessible to other functions in the
  //  class.  NOTE: That is a colon, NOT a semicolon...
  int processorspeed;
};
// Do Not forget the trailing semi-colon

Computer::Computer()
{
  //Constructors can accept arguments, but this one does not
  processorspeed = 0;
}

Computer::~Computer()
{
  //Destructors do not accept arguments
}

void Computer::setspeed ( int p )
{
  // To define a function outside put the name of the class
  //  after the return type and then two colons, and then the name
  //  of the function.
  processorspeed = p;
}
int Computer::readspeed()  
{
  // The two colons simply tell the compiler that the function is part
  //  of the class
  return processorspeed;
}

int main()
{
  Computer compute;  
  // To create an 'instance' of the class, simply treat it like you would
  //  a structure.  (An instance is simply when you create an actual object
  //  from the class, as opposed to having the definition of the class)
  compute.setspeed ( 100 ); 
  // To call functions in the class, you put the name of the instance,
  //  a period, and then the function name.
  cout<< compute.readspeed();
  // See above note.
}

This introduction is far from exhaustive and, for the sake of simplicity, recommends practices that are not always the best option. For more detail, I suggest asking questions on our forums and getting a book recommended by ourbook reviews.

Previous: Typecasting
Next: Functions Continued
Tutorial index

*Generic programming

Templates and Templated Classes in C++

What's better than having several classes that do the same thing to different datatypes? One class that lets you choose which datatype it acts on.

Templates are a way of making your classes more abstract by letting you define the behavior of the class without actually knowing what datatype will be handled by the operations of the class. In essence, this is what is known asgeneric programming; this term is a useful way to think about templates because it helps remind the programmer that a templated class does not depend on the datatype (or types) it deals with. To a large degree, a templated class is more focused on the algorithmic thought rather than the specific nuances of a single datatype. Templates can be used in conjunction with abstract datatypes in order to allow them to handle any type of data. For example, you could make a templated stack class that can handle a stack of any datatype, rather than having to create a stack class for every different datatype for which you want the stack to function. The ability to have a single class that can handle several different datatypes means the code is easier to maintain, and it makes classes more reusable.

The basic syntax for declaring a templated class is as follows:

template <class a_type> class a_class {...};

The keyword 'class' above simply means that the identifier a_type will stand for a datatype. NB: a_type is not a keyword; it is an identifier that during the execution of the program will represent a single datatype. For example, you could, when defining variables in the class, use the following line:

a_type a_var;

and when the programmer defines which datatype 'a_type' is to be when the program instantiates a particular instance of a_class, a_var will be of that type.

When defining a function as a member of a templated class, it is necessary to define it as a templated function:

template<class a_type> void a_class<a_type>::a_function(){...}

When declaring an instance of a templated class, the syntax is as follows:

a_class<int> an_example_class;

An instantiated object of a templated class is called a specialization; the term specialization is useful to remember because it reminds us that the original class is a generic class, whereas a specific instantiation of a class is specialized for a single datatype (although it is possible to template multiple types).

Usually when writing code it is easiest to precede from concrete to abstract; therefore, it is easier to write a class for a specific datatype and then proceed to a templated - generic - class. For that brevity is the soul of wit, this example will be brief and therefore of little practical application.

We will define the first class to act only on integers.

class calc
{
  public:
    int multiply(int x, int y);
    int add(int x, int y);
 };
int calc::multiply(int x, int y)
{
  return x*y;
}
int calc::add(int x, int y)
{
  return x+y;
}

We now have a perfectly harmless little class that functions perfectly well for integers; but what if we decided we wanted a generic class that would work equally well for floating point numbers? We would use a template.

template <class A_Type> class calc
{
  public:
    A_Type multiply(A_Type x, A_Type y);
    A_Type add(A_Type x, A_Type y);
};
template <class A_Type> A_Type calc<A_Type>::multiply(A_Type x,A_Type y)
{
  return x*y;
}
template <class A_Type> A_Type calc<A_Type>::add(A_Type x, A_Type y)
{
  return x+y;
}

To understand the templated class, just think about replacing the identifier A_Type everywhere it appears, except as part of the template or class definition, with the keyword int. It would be the same as the above class; now when you instantiate an
object of class calc you can choose which datatype the class will handle.

calc <double> a_calc_class;

Templates are handy for making your programs more generic and allowing your code to be reused later.

저작자표시

'프로그래밍 > C, C++' 카테고리의 다른 글

레슨 14: Accepting command line arguments (0)	2011.06.07
레슨 13: More on Functions (0)	2011.06.07
레슨 11: Typecasting (0)	2011.06.07
레슨 10: C++ File I/O (1)	2011.06.07
레슨 9: C Strings (0)	2011.06.07

레슨 9: C Strings

잡초사랑 2011. 6. 7. 12:47

2011. 6. 7. 12:47

Lesson 9: C Strings

In C++ there are two types of strings, C-style strings, and *C++-style strings. This lesson will discuss C-style strings. C-style strings are really arrays, but there are some different functions that are used for strings, like adding to strings, finding the length of strings, and also of checking to see if strings match. The definition of a string would be anything that contains more than one character strung together. For example, "This" is a string. However, single characters will not be strings, though they can be used as strings.

Strings are arrays of chars. String literals are words surrounded by double quotation marks.

 
"This is a static string"

To declare a string of 49 letters, you would want to say:

 
char string[50];

This would declare a string with a length of 50 characters. Do not forget that arrays begin at zero, not 1 for the index number. In addition, a string ends with a null character, literally a '\0' character. However, just remember that there will be an extra character on the end on a string. It is like a period at the end of a sentence, it is not counted as a letter, but it still takes up a space. Technically, in a fifty char array you could only hold 49 letters and one null character at the end to terminate the string.

TAKE NOTE: char *arry; Can also be used as a string. If you have read the tutorial on pointers, you can do something such as:

 
arry = new char[256];

which allows you to access arry just as if it were an array. Keep in mind that to use delete you must put [] between delete and arry to tell it to free all 256 bytes of memory allocated.

For example:

 
delete [] arry.

Strings are useful for holding all types of long input. If you want the user to input his or her name, you must use a string. Using cin>> to input a string works, but it will terminate the string after it reads the first space. The best way to handle this situation is to use the function cin.getline. Technically cin is a class (a beast similar to a structure), and you are calling one of its member functions. The most important thing is to understand how to use the function however.

The prototype for that function is:

 
istream& getline(char *buffer, int length, char terminal_char);

The char *buffer is a pointer to the first element of the character array, so that it can actually be used to access the array. The int length is simply how long the string to be input can be at its maximum (how big the array is). The char terminal_char means that the string will terminate if the user inputs whatever that character is. Keep in mind that it will discard whatever the terminal character is.

It is possible to make a function call of cin.getline(arry, 50); without the terminal character. Note that '\n' is the way of actually telling the compiler you mean a new line, i.e. someone hitting the enter key.

For a example:

 
#include <iostream>

using namespace std;

int main()
{
  char string[256];                               // A nice long string

  cout<<"Please enter a long string: ";
  cin.getline ( string, 256, '\n' );              // Input goes into string
  cout<<"Your long string was: "<< string <<endl;
  cin.get();
}

Remember that you are actually passing the address of the array when you pass string because arrays do not require an address operator (&) to be used to pass their address. Other than that, you could make '\n' any character you want (make sure to enclose it with single quotes to inform the compiler of its character status) to have the getline terminate on that character.

cstring is a header file that contains many functions for manipulating strings. One of these is the string comparison function.

 
int strcmp ( const char *s1, const char *s2 );

strcmp will accept two strings. It will return an integer. This integer will either be:

 
Negative if s1 is less than s2.
Zero if s1 and s2 are equal.
Positive if s1 is greater than s2.

Strcmp is case sensitive. Strcmp also passes the address of the character array to the function to allow it to be accessed.

 
char *strcat ( char *dest, const char *src );

strcat is short for string concatenate, which means to add to the end, or append. It adds the second string to the first string. It returns a pointer to the concatenated string. Beware this function, it assumes that dest is large enough to hold the entire contents of src as well as its own contents.

 
char *strcpy ( char *dest, const char *src );

strcpy is short for string copy, which means it copies the entire contents of src into dest. The contents of dest after strcpy will be exactly the same as src such that strcmp ( dest, src ) will return 0.

 
size_t strlen ( const char *s );

strlen will return the length of a string, minus the terminating character ('\0'). The size_t is nothing to worry about. Just treat it as an integer that cannot be negative, which it is.

Here is a small program using many of the previously described functions:

 
#include <iostream> //For cout
#include <cstring>  //For the string functions

using namespace std;

int main()
{
  char name[50];
  char lastname[50];
  char fullname[100]; // Big enough to hold both name and lastname
  
  cout<<"Please enter your name: ";
  cin.getline ( name, 50 );
  if ( strcmp ( name, "Julienne" ) == 0 ) // Equal strings
    cout<<"That's my name too.\n";
  else                                    // Not equal
    cout<<"That's not my name.\n";
  // Find the length of your name
  cout<<"Your name is "<< strlen ( name ) <<" letters long\n";
  cout<<"Enter your last name: ";
  cin.getline ( lastname, 50 );
  fullname[0] = '\0';            // strcat searches for '\0' to cat after
  strcat ( fullname, name );     // Copy name into full name
  strcat ( fullname, " " );      // We want to separate the names by a space
  strcat ( fullname, lastname ); // Copy lastname onto the end of fullname
  cout<<"Your full name is "<< fullname <<"\n";
  cin.get();
}

Safe Programming

The above string functions all rely on the existence of a null terminator at the end of a string. This isn't always a safe bet. Moreover, some of them, noticeably strcat, rely on the fact that the destination string can hold the entire string being appended onto the end. Although it might seem like you'll never make that sort of mistake, historically, problems based on accidentally writing off the end of an array in a function like strcat, have been a major problem.

Fortunately, in their infinite wisdom, the designers of C have included functions designed to help you avoid these issues. Similar to the way that fgets takes the maximum number of characters that fit into the buffer, there are string functions that take an additional argument to indicate the length of the destination buffer. For instance, the strcpy function has an analogous strncpy function

 
char *strncpy ( char *dest, const char *src, size_t len );

which will only copy len bytes from src to dest (len should be less than the size of dest or the write could still go beyond the bounds of the array). Unfortunately, strncpy can lead to one niggling issue: it doesn't guarantee that dest will have a null terminator attached to it (this might happen if the string src is longer than dest). You can avoid this problem by using strlen to get the length of src and make sure it will fit in dest. Of course, if you were going to do that, then you probably don't need strncpy in the first place, right? Wrong. Now it forces you to pay attention to this issue, which is a big part of the battle.

Still not getting it? Ask an expert!

Quiz yourself
Previous: Arrays
Next: File I/O
Tutorial index

*C++-style strings.

The C++ String Class

C++ provides a simple, safe alternative to using char*s to handle strings. The C++ string class, part of the std namespace, allows you to manipulate strings safely.

Declaring a string is easy:

using namespace std;

string my_string;

std::string my_string;

You can also specify an initial value for the string in a constructor:

using namespace std;
string my_string("starting value");

String I/O is easy, as strings are supported by cin.

cin>>my_string;

If you need to read an entire line at a time, you can use the getline function and pass in an input stream object (such as cin, to read from standard input, or a stream associated with a file, to read from a file), the string, and a character on which to terminate input. The following code reads a line from standard input (e.g., the keyboard) until a newline is entered.

using namespace std;
getline(cin, my_string, '\n');

Strings can also be assigned to each other or appended together using the + operator:

string my_string1 = "a string";
string my_string2 = " is this";
string my_string3 = my_string1 + my_string2;

// Will ouput "a string is this"
cout<<my_string3<<endl;

Naturally, the += operator is also defined! String concatenation will work as long as either of the two strings is a C++ string--the other can be a static string or a char*.

String Comparisons

One of the most confusing parts of using char*s as strings is that comparisons are tricky, requiring a special comparison function, and using tests such as == or < don't mean what you'd expect. Fortunately, for C++ strings, all of the typical relational operators work as expected to compare either C++ strings or a C++ string and either a C string or a static string (i.e., "one in quotes").

For instance, the following code does exactly what you would expect, namely, it determines whether an input string is equal to a fixed string:

string passwd;

getline(cin, passwd, '\n');
if(passwd == "xyzzy")
{
    cout<<"Access allowed";
}

String Length and Accessing Individual Elements

To take the length of a string, you can use either the length or size function, which are members of the string class, and which return the number of characters in a string:

string my_string1 = "ten chars.";
int len = my_string1.length(); // or .size();

Strings, like C strings (char*s), can be indexed numerically. For instance, you could iterate over all of the characters in a string indexing them by number, as though the the string were an array.

Note that the use of the length() or size() function is important here because C++ strings are not guaranteed to be null-terminated (by a '\0'). (In fact, you should be able to store bytes with a value of 0 inside of a C++ string with no adverse effects. In a C string, this would terminate the string!)

int i;
for(i = 0; i < my_string.length(); i++)
{
    cout<<my_string[i];
}

On the other hand, strings are actually sequences, just like any other STL container, so you can use iterators to iterate over the contents of a string.

string::iterator my_iter;
for(my_iter = my_string.begin(); my_iter != my_string.end(); my_iter++)
{
    cout<<*my_iter;
}

Note that my_string.end() is beyond the end of the string, so we don't want to print it, whereas my_string.begin() is at the first character of the string.

Incidentally, C++ string iterators are easily invalidated by operations that change the string, so be wary of using them after calling any string function that may modify the string.

Searching and Substrings

The string class supports simple searching and substring retrieval using the functions find(), rfind(), and substr(). The find member function takes a string and a position and begins searching the string from the given position for the first occurence of the given string. It returns the position of the first occurence of the string, or a special value, string::npos, that indicates that it did not find the substring.

This is what the find function prototype would look like. (Note that I've used ints here for clarity, but they would actually be of the type "size_type", which is unsigned.)

int find(string pattern, int position);

This sample code searches for every instance of the string "cat" in a given string and counts the total number of instances:

string input;
int i = 0;
int cat_appearances = 0;

getline(cin, input, '\n');

for(i = input.find("cat", 0); i != string::npos; i = input.find("cat", i))
{
    cat_appearances++;
    i++;  // Move past the last discovered instance to avoid finding same
          // string
}
cout<<cat_appearances;

Similarly, it would be possible to use rfind in almost the exact same way, except that searching would begin at the very end of the string, rather than the beginning. (String matches would still be from left-to-right--that is, it wouldn't match "cat" with a string containing "tac".) How would you need to modify the above program to use rfind?

On the other hand, the substr function can be used to create a new string consisting only of the slice of the string beginning at a given position and of a particular length:

// sample prototype
string substr(int position, int length);

For instance, to extract the first ten characters of a string, you might use

string my_string = "abcdefghijklmnop";
string first_ten_of_alphabet = my_string.substr(0, 10);
cout<<"The first ten letters of the alphabet are "
    <<first_ten_of_alphabet;

Modifying Strings via Splicing or Erasure

It's also possible to modify C++ strings to either remove part of a string or add in new text. The erase() function looks very similar to substr in its prootype; it takes a position and a character count and removes that many characters starting from the given position. Note that position is zero-indexed, as usual.

string my_removal = "remove aaa";
my_removal.erase(7, 3); // erases aaa

To delete an entire string, you could use

str.erase(0, str.length());

On the other hand, you can also splice one string into another. The member function insert takes a position and a string and inserts that string starting at the given position:

string my_string = "ade";
my_string.insert(1, "bc");
// my_string is now "abcde"
cout<<my_string<<endl;

String concatenation can be implemented in terms of insert, using the position past the last element of the string as the insertion point (i.e., the str.length()). Trying to insert beyond the length of the string will result in a segmentation fault.

Copying vs. Sharing

Because strings are mutable (they can change what they hold), it is important to know whether strings are copied or share the same memory. (This matters if, for instance, you pass a string to a function that modifies the string--does it also modify the string passed in to the function because they share the same memory storing the actual string?) It turns out that, in effect, they are copied, but in practice, it's possible that your implementation may delay copying until absolutely necessary. As a result, some operations you might expect to be slow, such as passing a large string to a function, may turn out to be faster than expected. Of course, before you rely on this behavior, you should check your implementation to make sure that it delays copies when not necessary.

Retrieving a char*

Sometimes it can be useful to retrieve a char* from a C++ string. This might be necessary for use with a particular C standard library function that takes a char*, or for compatibility with older code that expects a char* rather than a C++ string. The string member function c_str() will return the string in the form of a char* (with a null-terminator).

// The prototype:
const char* c_str();

// usage example
string my_string = x;
cout<<strlen(my_string.c_str());

Notice that the returned char* is a const value; you should not try to modify this string (it is read-only), and you do not need to free/delete it. Doing so is an error. If you need to modify the char*, you should create a second string and use the strcpy function to duplicate the result of calling c_str().

basic_string

Although the string class is useful, it may not suit your needs for internationalization. In particular, if you need support for a different character set or wide characters, you may want something a bit different. For this, you can take advantage of the basic_string template, from which string itself is derived.

typedef basic_string<char> string;

If you need to use a string with, say, wide characters, you can declare a basic string to store the sequence of characters:

basic_string<wchar_t> wide_char_str;

// or even just

basic_string<unsigned char> u_char_str;

This, too, can be simplified using typedef:

typedef basic_string<unsigned char> ustring;

저작자표시

'프로그래밍 > C, C++' 카테고리의 다른 글

레슨 11: Typecasting (0)	2011.06.07
레슨 10: C++ File I/O (1)	2011.06.07
레슨 8: Array basics (0)	2011.06.07
레슨 7: Structures (0)	2011.06.07
레슨 6: An introduction to pointers (0)	2011.06.07

PREV 이전 1 NEXT 다음

잡초사랑

CLASS

레슨 12: Introduction to Classes

Templates and Templated Classes in C++

'프로그래밍 > C, C++' 카테고리의 다른 글

레슨 9: C Strings

Lesson 9: C Strings

Safe Programming

The C++ String Class

String Comparisons

String Length and Accessing Individual Elements

Searching and Substrings

Modifying Strings via Splicing or Erasure

Copying vs. Sharing

Retrieving a char*

basic_string

'프로그래밍 > C, C++' 카테고리의 다른 글

+ Recent posts

티스토리툴바