Tuesday, 22 September 2009

Transcription

1 Scope in C++ Lecture 6 Object Lifetimes In C++ scope is delimited by the { } Any variables declared within these sections are only valid within the braces This is also true for the following int main() 5 { 6! "#(int i=0; i<10; ++i) 7 { 8 std::cout<<i; 9 } 10 std::cout<<i; #$ %&# EXIT_SUCCESS; 1 } loop scope If we compile the previous example we get the following error message 1 forloop.cpp: In function 'int main()': 2 forloop.cpp:10: error: name lookup of 'i' changed for new ISO 'for' scoping forloop.cpp:6: error: using obsolete binding at 'i' Brace Scope 5 int global=1; 6 7 int main() 8 { 9 int local=2; 10 { 11 int brace1=; 12 { 1 int brace2=; 1 std::cout<<global<<" "<<local<<" "<<brace1<<" "<<brace2<<"\n"; 15 } 16 std::cout<<global<<" "<<local<<" "<<brace1<<"\n"; 17 } 18 std::cout<<global<<" "<<local<<"\n"; return EXIT_SUCCESS; 21 }

2 Object Lifetimes We have already seen how to create a simple class to contain data and operations performed on that data Another part of class design is how to create a class in a specific way and control it s lifetime A Class has two special member functions which allow for this know as the constructor (ctor) destructor (dtor) Constructors When an object is created there are certain processes which must take place Instantiation always involves the allocation of memory for the objects state data. The methods do not require and memory as these are consistent for all objects of the class and are handled in the class itself. The special method which allocates the memory for an object is know as the 'constructor' There are three basic types of constructor The default constructor User defined Constructor The Copy Constructor The default constructor The default constructor takes no parameters (or return type) It performs no processing on the object data just memory allocation It will always be called by the compiler if no user defined constructor is provided The default constructor is not referred to by the programmer in the class definition User Defined Constructors These constructors may be used to pass parameter values to the object These may be used to set default object values It is possible to have more than one constructor in a class passing different parameters This is known as overloading and gives more flexibility to the way the object can be instantiated

3 Example Class The diagram is a UML class diagram It show sections The class Name The attributes The Methods Writing a constructor The constructor takes the same name as the class. It does not return any type but may have parameters. The following code writes a default constructor for the Vector class It sets some default values for the attributes x,y,z,w 1 #ifndef VECTOR_H_ 2 #define VECTOR_H_ #include <cmath> #include <iostream> 5 6 class Vector 7 { 8 9 public: 10 union 11 { 12 struct 1 { 1 /*! x component of the vector */ 15 float x; 16 /*! y component of the vector */ 17 float y; 18 /*! z component of the vector */ 19 float z; 20 /*! w component of the vector 0= Vector 1=Point*/ 21 float w; 22 }; 2 float OpenGL[]; 2 }; // initialize from or Reals (default to a point) 27 Vector(); 28 void Print(); 29 }; 0 #endif 1 #include "Vector.h" 2 #include <iostream> Vector::Vector() 5 { 6 x=y=z=w=0.0; 7 8 } 9 10 void Vector::Print() 11 { 12 std::cout<<"["<<x<<","<<y<<","<<z<<","<<w<<"]\n"; 1 }

4 Using a class The following code creates an instance of the Vector class using two different techniques The first is a static object with the usual brace scope lifetime The second is a dynamic object which must be deleted as it is based on a pointer As you can see the pointer based class needs to be de-referenced using the pointed to -> construct. #include "Vector.h" 5 int main() 7! " #$%V1; 8! " #$%*V2 = new! " #$%(); 9 10 V1.Print(); 11 V2->Print(); 12 1 delete V2; 1 %#&%' EXIT_SUCCESS; 15 } User Defined ctor In the previous example the ctor is very simple and not particularly flexible. It would make more sense for the user to supply the values for x,y,z,w to the ctor To do this we can write a ctor in the following way to allow this 1 Vector(float nx=0.0,float ny=0.0,float nz=0.0,float nw=1.0f) : x(nx),y(ny),z(nz),w(nw){;} Concepts 1 Vector(float nx=0.0,float ny=0.0,float nz=0.0,float nw=1.0f) : x(nx),y(ny),z(nz),w(nw){;} The constructor is quite complex and has a number of new concepts First we pass default values to the attributes x=0.0 Next we use the : operator Then we use the x(nx) constructor for the float to set the attribute value As this is in the header we need to write the body code as well {;}

5 #include "Vector.h" 5 int main() 7 Vector V1; 8 Vector V2(2.0f,2.0f); 9 Vector V(.0f,.0f,.0f); 10 Vector V(.0f,.0f,.0f,0.0); V1.Print(); 1 V2.Print(); 1 V.Print(); 15 V.Print(); return EXIT_SUCCESS; 18 } In this example we can construct as follows No params 2 floats floats floats The copy ctor A copy ctor is used to create an object from an existing object We pass a const reference to the object to be copied (so the original can t be modified) By default the compiler will create a copy ctor for us (know as an implicit copy ctor) This is usually enough unless the class creates pointers or file references when we need to create an explicit copy ctor. 1 Vector(const Vector& np) : x(np.x), y(np.y), z(np.z), w(np.w){;} #include "Vector.h" 5 int main() 7! " #$%V1(1,2,,0); 8! " #$%V2(V1); 9! " #$%V=V2; V1.Print(); 12 V2.Print(); 1 V.Print(); 1 15 %#&%' EXIT_SUCCESS; 16 } destructor 1 Vector(); 2 Vector:: Vector(); The destructor is called when the object is destroyed. It takes the same name as the class but with a ~ It is used to remove resources allocated in the class If nothing is allocated we usually don t need to write a dtor

6 The rule of three is a rule of thumb in C++ that claims that if a class defines one of the following it should probably explicitly define all three destructor copy constructor copy assignment operator (more on this in a few weeks) Example 1 #ifndef MEM_H 2 #define MEM_H class Mem 5 { 6 private : 7 int *mem; 8 int size; 9 public : 10 Mem(int _size); 11 Mem(const Mem &m); 12 Mem(); 1 void Print(); 1 void set(int offset,int value); 15 }; #endif 1 #include "Mem.h" 2 #include <iostream> Mem::Mem(int _size) 5 { 6 std::cout<<"ctor called\n"; 7 mem = new int[_size]; 8 size=_size; 9 } Mem::Mem(const Mem &m) 12 { 1 std::cout<<"copy ctor Called\n"; 1 size=m.size; 15 // allocate new memory 16 mem = new int[size]; 17 // now copy the data from the original 18 for(int i=0; i<size; ++i) 19 mem[i]=m.mem[i]; 20 } Mem:: Mem() 2 { 2 std::cout<<"dtor called\n"; 25 delete [] mem; 26 } void Mem::Print() 0 { 1 for(int i=0; i<size; ++i) 2 std::cout<<mem[i]<<std::endl; } 5 void Mem::set(int offset,int value) 7 assert(offset<size); 8 mem[offset]=value; 9 } #include "Mem.h" 5 int main(void) 7 Mem a(); 8 for (int i=0; i<; ++i) 9 a.set(i,i); Mem b=a; 12 Mem c=a; 1 b.set(0,99); 1 c.set(0,299); std::cout<<"printing A"<<std::endl; 17 a.print(); 18 std::cout<<"printing b"<<std::endl; 19 b.print(); 20 std::cout<<"printing c"<<std::endl; 21 c.print(); 22 return EXIT_SUCCESS; 2 } 1 ctor called 2 Copy ctor Called Copy ctor Called Printing A Printing b Printing c dtor called 20 dtor called 21 dtor called The singleton Pattern The singleton pattern defines an object that can only exist once This is done by implementing the code in a particular way with the object knowing if it has been created. If it has not it will create an instance of itself If it has been created it will return the instance. This pattern is a good way of storing global state data within a program.

7 a a a a 1 #ifndef GLOBAL_H 2 #define GLOBAL_H #include <iostream> 5 6 class Global 7 { 8 public : 9 static Global* Instance(); 10 void setname(const std::string &n); 11 std::string getname(); 12 void setage(int a); 1 int getage(); 1 15 private : 16 static Global* pinstance; 17 std::string name; 18 int age; }; #endif 1 #include "Global.h" 2 Global* Global::pinstance = 0; / / i n i t i l i ze po i n t er 5 Global* Global::Instance() 7 if (pinstance == 0) / / i s i t the f c? 8 { 9 pinstance = new Global; / / c s i nst nce 10 } 11 return pinstance; / / d d r e s s of s i nst nce 12 } void Global::setName(const std::string &n) 17 { 18 name=n; 19 } std::string Global::getName() 22 { 2 return name; 2 } void Global::setAge(int a) 27 { 28 age=a; 29 } 0 1 int Global::getAge() 2 { return age; } #include "Global.h" 5 6 Global *data=global::instance(); 7 8 void SetData() 9 { 10 data->setname("jon"); 11 data->setage(9); 12 } 1 1 void PrintData() 15 { 16 std::cout<<"name = "<<data->getname()<<"\n"; 17 std::cout<<"age = "<<data->getage()<<"\n"; } 20 int main() 21 { 22 SetData(); 2 PrintData(); 2 25 return EXIT_SUCCESS; 26 } #include "Global.h" 5 6 void SetData() 7 { 8 Global *data=global::instance(); 9 data->setname("jon"); 10 data->setage(9); 11 } 12 1 void PrintData() 1 { 15 Global *data=global::instance(); 16 std::cout<<"name = "<<data->getname()<<"\n"; 17 std::cout<<"age = "<<data->getage()<<"\n"; } 20 int main() 21 { 22 PrintData(); 2 SetData(); 2 PrintData(); return EXIT_SUCCESS; 27 }

8 References Stroustrup, Bjarne (2000). The C++ Programming Language ( ed.). Addison-Wesley. pp.!28. Further Reading %2B%2B_programming% %28computer_science%29#C.2B.2B