Javascript Disabled Detected

You currently have javascript disabled. Several functions may not work. Please re-enable javascript to access full functionality.


Welcome to AstaHost - Dear Guest , Please Register here to get Your own website. - Ask a Question / Express Opinion / Reply w/o Sign-Up!

Replying to C++: Basic Classes

Post Options

Enable emoticons?

Enter Your Name

Security Check *

[quote name="bluefish" post="95441" timestamp="1168211964"] This tutorial assumes that you have a basic knowledge of C++. You know how to use built-in types, like ints, doubles, chars, etc. You should know some types that are part of the STL, like vector, etc. Those types that come in the STL are just C++; you can create your own types just like those! Non built-in types are referred to as [b]classes[/b]. To create a class, you just use the keyword [i]class[/i], the name of the class, and curly brackets. [code=auto:0]//A class named MyClassclass MyClass {};[/code] In fact, that is all we need to create variables, pointers, or references to that class. [code=auto:0]MyClass a;MyClass *b = &a;MyClass &c = a;[/code] The variable "a" is an [b]object[/b] of type MyClass. Of course, something like that hardly does anything. We need to create [b]members[/b] of that class - ways it can be created (called [b]constructors[/b]), operations that we can perform on it (called [b]member functions[/b]), and data it can hold (called [b]data members[/b]). [b]Data Members[/b] I'll start with data members, because you often need them to use constructors and member functions. A data member is a piece of data, the same as you use normally. It can be a built-in type, or another class type (i.e. vector). A class can have as many data members as you want or need. To declare a data member, simply put the declaration in the body of the class as follows: [code=auto:0]#include <vector>class MyClass {int i;std::vector<int> v;};[/code] So MyClass has two data members: i and v. Normal rules apply. You can also use pointers and references as usual. - An important thing to note is that i and v are uninitialized. We'll talk about initializing data members later. - Also, each object of type MyClass has its own different data. The data is referred to by the same name, but each object of type MyClass has its own value for i and v. [b]Access Control[/b] Before we move on, I would like to discuss access control. There are three main types of access control in a class. public: Any part of the program can access it private: Only members of the class can access it protected: Private except inherited classes can access it [color=#FF0000]NOT COVERED[/color] To change access control, just use the name followed by a colon, and that will be the access control from then on. The default access control is private. You can bypass this by using the [i]struct[/i] keyword instead of class - the default access control is then public. [code=auto:0]#include <vector>class MyClass {int i; //Default is privatepublic:int integer; //Publicprivate:vector v; //Privateprotected:vector vec; //Protected};struct MyClass2 {int i; //Public, as defaultprivate:int i2; //Private};[/code] - A common mistake is to assume that struct has a deeper meaning. It doesn't. It's the exact same as using class and following it with "public:". - To access a public member of a class, use ObjectName.MemberName. So, using the above example: [code=auto:0]MyClass c;c.integer = 10; //Value of integer is changedc.i = 10; //Error: private member cannot be accessed[/code] [b]Constructors[/b] Usually, we need to do something when a class is created. We also often need to have different ways to create objects of the same type. That is why we have constructors. A constructor looks a bit like a function, with a few key differences. For one, it has no return value. Its name [i]must[/i] be the same as the class name. For example: [code=auto:0]#include <vector>class MyClass {public:MyClass() {//Constructori = 10;v.push_back(i);}int i;std::vector<int> v;};[/code] As you can see, you can do anything you want with your data members in the constructor. So now, when we create an object like the following, the operations in the [b]default constructor[/b] are called. The default constructor is a constructor with no arguments, and it is called whenever an object of that type is created. [code=auto:0]MyClass my;[/code]Since my is initialized with the default constructor, i should now have a value of 10 and v should have one element with a value of 10. Also, constructors can take values like a normal function. [code=auto:0]#include <vector>class MyClass {public://Default constructorMyClass() {i = 10;v.push_back(i);}//Constructor that takes an argumentMyClass(int i2) {i = i2;v.push_back(i);}int i;std::vector<int> v;};//...MyClass a; //Initializes with default constructorMyClass b(); //Initializes with default constructorMyClass c(4); //Initializes with second constructor[/code] Another important concept is an initializer list. With the above method, your compiler automatically initializes all the data members to their default value, then executes the body of the constructor. This is normally not a big deal, but if you have big classes where initializing them takes a lot of resources, it can be important to do it only once. That is why initializer lists are provided. You can change the default initialization, with the following as an example. [code=auto:0]#include <vector>class MyClass {public://Default constructorMyClass() : i(10), v(7,2) { //Initialize i with a value of 10; v is initialized with 2 elements with a value of 7v.push_back(i);}//Constructor that takes an argumentMyClass(int i2) : i(i2) { //Initialize i with the argument i2v.push_back(i);}int i;std::vector<int> v;};[/code] To create the initializer list, follow the argument list with a colon, then initialize each data member with whatever values. Multiple initializations are seperated by commas. When you use the initializer lists, you can ensure that the data members are initialized only once. - If you do not provide a default constructor, your compiler will [b]synthesize[/b] one for you. This constructor does nothing except initialize all the data members to their default values. - If your default constructor is private, objects must be created with another constructor - if there are no public constructors, objects of that type cannot be created. Note that the synthesized constructor is public. [b]Member Functions[/b] A member function is an operation that can be performed on an object. You can declare member functions in the same way as normal functions, except within the body of the class. Member functions can use data members and can call other member functions. They cannot call constructors, but constructors can call them. You can use access control for member functions. Public functions can be performed as Object.Function(args). Private (or protected) member functions can only be called by other members. [code=auto:0]#include <vector>class MyClass {public:void setI(int i2) { i = i2; }int getI() { return i; }void multiplyBy6() { doubleI(); tripleI(); }private:void doubleI() { i *= 2; }void tripleI() { i *= 3; }int i;};//...MyClass m;m.setI(10);int i = m.getI(); //i==10m.multiplyBy6(); //i==60m.doubleI(); //Error: can't access private member function[/code] The body of a member function does not need to be defined inside the class. It can be defined outside, by declaring it inside and using the scope operator (double colon). [code=auto:0]class MyClass {public:int getI();int i;};int MyClass::getI() {return i;}[/code] This operates the same as getI in the previous example, with one difference. [b]Inline Functions[/b] An inline function is a function that is actually changed into the appropriate code by the compiler. With short functions, this can increase run-time efficiency. Member functions that are defined within a class are inline by default. Member functions defined outside the class and normal functions need the [i]inline[/i] keyword. [code=auto:0]inline int sum(int i, int i2) { //Inline functionreturn i1+i2;}class MyClass {public:int getI();int setI(int i2) { i = i2; } //Inline by defaultint i;};inline int MyClass::getI() { //Inline by keywordreturn i;}[/code] - Note that calling a function inline is a request, not a guarantee. Functions that are expanded inline may actually be slower if they are large or if there are certain other conditions. It is up to the compiler to determine whether to expand a function inline or not. It is not a good idea to call all your functions inline; it should only be used on short, simple functions called many times. That is a basic introduction to classes. Reply if you have questions, comments, etc.[/quote] [quote name="bluefish" post="95441" timestamp="1168211964"] This tutorial assumes that you have a basic knowledge of C++. You know how to use built-in types, like ints, doubles, chars, etc. You should know some types that are part of the STL, like vector, etc. Those types that come in the STL are just C++; you can create your own types just like those! Non built-in types are referred to as [b]classes[/b]. To create a class, you just use the keyword [i]class[/i], the name of the class, and curly brackets. [code=auto:0]//A class named MyClass class MyClass { };[/code] In fact, that is all we need to create variables, pointers, or references to that class. [code=auto:0]MyClass a; MyClass *b = &a; MyClass &c = a;[/code] The variable "a" is an [b]object[/b] of type MyClass. Of course, something like that hardly does anything. We need to create [b]members[/b] of that class - ways it can be created (called [b]constructors[/b]), operations that we can perform on it (called [b]member functions[/b]), and data it can hold (called [b]data members[/b]). [b]Data Members[/b] I'll start with data members, because you often need them to use constructors and member functions. A data member is a piece of data, the same as you use normally. It can be a built-in type, or another class type (i.e. vector). A class can have as many data members as you want or need. To declare a data member, simply put the declaration in the body of the class as follows: [code=auto:0]#include <vector> class MyClass { int i; std::vector<int> v; };[/code] So MyClass has two data members: i and v. Normal rules apply. You can also use pointers and references as usual. - An important thing to note is that i and v are uninitialized. We'll talk about initializing data members later. - Also, each object of type MyClass has its own different data. The data is referred to by the same name, but each object of type MyClass has its own value for i and v. [b]Access Control[/b] Before we move on, I would like to discuss access control. There are three main types of access control in a class. public: Any part of the program can access it private: Only members of the class can access it protected: Private except inherited classes can access it [color=#FF0000]NOT COVERED[/color] To change access control, just use the name followed by a colon, and that will be the access control from then on. The default access control is private. You can bypass this by using the [i]struct[/i] keyword instead of class - the default access control is then public. [code=auto:0]#include <vector> class MyClass { int i; //Default is private public: int integer; //Public private: vector v; //Private protected: vector vec; //Protected }; struct MyClass2 { int i; //Public, as default private: int i2; //Private };[/code] - A common mistake is to assume that struct has a deeper meaning. It doesn't. It's the exact same as using class and following it with "public:". - To access a public member of a class, use ObjectName.MemberName. So, using the above example: [code=auto:0]MyClass c; c.integer = 10; //Value of integer is changed c.i = 10; //Error: private member cannot be accessed[/code] [b]Constructors[/b] Usually, we need to do something when a class is created. We also often need to have different ways to create objects of the same type. That is why we have constructors. A constructor looks a bit like a function, with a few key differences. For one, it has no return value. Its name [i]must[/i] be the same as the class name. For example: [code=auto:0]#include <vector> class MyClass { public: MyClass() { //Constructor i = 10; v.push_back(i); } int i; std::vector<int> v; };[/code] As you can see, you can do anything you want with your data members in the constructor. So now, when we create an object like the following, the operations in the [b]default constructor[/b] are called. The default constructor is a constructor with no arguments, and it is called whenever an object of that type is created. [code=auto:0]MyClass my;[/code]Since my is initialized with the default constructor, i should now have a value of 10 and v should have one element with a value of 10. Also, constructors can take values like a normal function. [code=auto:0]#include <vector> class MyClass { public: //Default constructor MyClass() { i = 10; v.push_back(i); } //Constructor that takes an argument MyClass(int i2) { i = i2; v.push_back(i); } int i; std::vector<int> v; }; //... MyClass a; //Initializes with default constructor MyClass b(); //Initializes with default constructor MyClass c(4); //Initializes with second constructor[/code] Another important concept is an initializer list. With the above method, your compiler automatically initializes all the data members to their default value, then executes the body of the constructor. This is normally not a big deal, but if you have big classes where initializing them takes a lot of resources, it can be important to do it only once. That is why initializer lists are provided. You can change the default initialization, with the following as an example. [code=auto:0]#include <vector> class MyClass { public: //Default constructor MyClass() : i(10), v(7,2) { //Initialize i with a value of 10; v is initialized with 2 elements with a value of 7 v.push_back(i); } //Constructor that takes an argument MyClass(int i2) : i(i2) { //Initialize i with the argument i2 v.push_back(i); } int i; std::vector<int> v; };[/code] To create the initializer list, follow the argument list with a colon, then initialize each data member with whatever values. Multiple initializations are seperated by commas. When you use the initializer lists, you can ensure that the data members are initialized only once. - If you do not provide a default constructor, your compiler will [b]synthesize[/b] one for you. This constructor does nothing except initialize all the data members to their default values. - If your default constructor is private, objects must be created with another constructor - if there are no public constructors, objects of that type cannot be created. Note that the synthesized constructor is public. [b]Member Functions[/b] A member function is an operation that can be performed on an object. You can declare member functions in the same way as normal functions, except within the body of the class. Member functions can use data members and can call other member functions. They cannot call constructors, but constructors can call them. You can use access control for member functions. Public functions can be performed as Object.Function(args). Private (or protected) member functions can only be called by other members. [code=auto:0]#include <vector> class MyClass { public: void setI(int i2) { i = i2; } int getI() { return i; } void multiplyBy6() { doubleI(); tripleI(); } private: void doubleI() { i *= 2; } void tripleI() { i *= 3; } int i; }; //... MyClass m; m.setI(10); int i = m.getI(); //i==10 m.multiplyBy6(); //i==60 m.doubleI(); //Error: can't access private member function[/code] The body of a member function does not need to be defined inside the class. It can be defined outside, by declaring it inside and using the scope operator (double colon). [code=auto:0]class MyClass { public: int getI(); int i; }; int MyClass::getI() { return i; }[/code] This operates the same as getI in the previous example, with one difference. [b]Inline Functions[/b] An inline function is a function that is actually changed into the appropriate code by the compiler. With short functions, this can increase run-time efficiency. Member functions that are defined within a class are inline by default. Member functions defined outside the class and normal functions need the [i]inline[/i] keyword. [code=auto:0]inline int sum(int i, int i2) { //Inline function return i1+i2; } class MyClass { public: int getI(); int setI(int i2) { i = i2; } //Inline by default int i; }; inline int MyClass::getI() { //Inline by keyword return i; }[/code] - Note that calling a function inline is a request, not a guarantee. Functions that are expanded inline may actually be slower if they are large or if there are certain other conditions. It is up to the compiler to determine whether to expand a function inline or not. It is not a good idea to call all your functions inline; it should only be used on short, simple functions called many times. That is a basic introduction to classes. Reply if you have questions, comments, etc.[/quote]

or Cancel

Topic Summary

vistz

Posted 25 October 2010 - 11:16 PM

By the way, the pointer thing is one of the most inportant functionalities in C and C++.

And I also know that allocating memory is also an important factor

yordan

Posted 29 September 2010 - 08:58 AM

Of course, there's the addition of pointers that I have to worry about also.

By the way, the pointer thing is one of the most inportant functionalities in C and C++.

Although I haven't done extensive programming in C++, I have found that many of the practices in Java are also implemented in C++. Of course, there's the addition of pointers that I have to worry about also.

Posted 11 December 2009 - 12:28 PM

struct/class difference correctionC++: Basic ClassesA struct is not the "exact same" as a public classFrom C++ standard (11.2.2):"In absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class."Additionally, (11.2):"Member of a class defined with the keyword class are private by default. Members of a class defined with the keywords struct or union are public by default."-reply by richard

Posted 17 May 2009 - 05:40 PM

Thanks u very much ^^. Your notes are very useful for me. I wish all Learn programming books had clear ideals like yours. You make me to love C++ so more!

-reply by Thang Doan Minh

Gr33nN1nj4

Posted 11 August 2008 - 06:02 AM

Access private member function without using friend class

C++: Basic Classes
I want to use private member function in other class , how can I access without using friend.

-question by Aijaz Ahmad

You can't as that is the idea behind private functions/variables, think of them as globals but only for that class. What you could do(assuming you have access to the source) is create a public "proxy" function think simply passes the given variables to the private function. For private variables I would recommend implanting get/set functions.

example of a get/set

class MyClass
{
	public:
		MyClass() // :) never forget to initialize your values.. bad things will happen if you don't
		{
			number = 0;
		}

		virtual int get_number() // Returns the value of the private member number
		{
			return number;
		} 

		virtual void set_number(int value) // Sets number to equal value
		{
			number = value;
		}

	private:
		int number;
};

Posted 09 May 2008 - 07:58 AM

Access private member function without using friend class
C++: Basic Classes

I want to use private member function in other class , how can I access without using friend.

-question by Aijaz Ahmad

Posted 30 January 2008 - 01:15 PM

Thanks...
Very simple illustrations...!

-venkatraman.S

qwijibow

Posted 28 February 2007 - 01:36 PM

And Dont forget to end the class with a semi colon ';'

class
{
};

quinciest

Posted 01 February 2007 - 04:57 AM

thanks for the tutorial
although i've read it in book
but i more understand read this one

Review the complete topic (launches new window)