A <Basic> C++ Course. Julien Deantoni. 7 - The document example. adapted from Jean-Paul Rigault courses
|
|
|
- Stephen Elwin Beasley
- 5 years ago
- Views:
Transcription
1 A <Basic> C++ Course 7 - The document example Julien Deantoni adapted from Jean-Paul Rigault courses
2 This Week Just an example... Programmation multi paradigmes en C++ 2
3 Document example: basic specifications Consider (unstructured) text documents. A Document is composed of: 1. a title, 2. A set of authors, 3. an ordered collection of contained paragraphs, 4. an ordered collection of referenced paragraphs. Programmation multi paradigmes en C++ 3
4 Document example:basic specifications Consider (unstructured) text documents. A Document offer the possibility of: 1. Adding a paragraph. A paragraph can be add as a paragraphs or as an external_paragraphs depending on a boolean Programmation multi paradigmes en C++ 4
5 Document example:basic specifications A Paragraph is composed of: 1. a title, 2. a string representing the content, 3. an association to its owner. Programmation multi paradigmes en C++ 5
6 Document example: basic specifications General title (Author,...) paragraph title 1 Bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. Document paragraph title 2 Bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. Paragraphs Programmation multi paradigmes en C++ 6
7 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 7
8 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 8
9 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 9
10 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 10
11 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 11
12 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Note the difference between containment and association Programmation multi paradigmes en C++ 12
13 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", Note the difference between containment and association There are various points of view on this concern. You can choose your point of view but you will vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), have to motivate your choice. vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructorfor me, when there is a containment, the object Document(const Document&); life is under the responsibility of the container. Otherwise it is not. void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 13
14 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 14
15 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; Default parameters that explicitly call a constructor Programmation multi paradigmes en C++ 15
16 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; A name must be set to explicitly call a constructor Default parameters that explicitly call a constructor Programmation multi paradigmes en C++ 16
17 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); + all the relevant accessors!! (get / set) void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 17
18 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), ; Accessors allow control vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); + all the relevant accessors!! (get / set / add / remove) void append(paragraph&, bool); Programmation multi paradigmes en C++ 18
19 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), ; Accessors allow control vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); + all the relevant accessors!! (get / set / add / remove) void append(paragraph&, bool); Programmation multi paradigmes en C++ 19
20 Document example:basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), ; Accessors allow control vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); + all the relevant accessors!! (get / set / add / remove) void append(paragraph&, bool); Programmation multi paradigmes en C++ 20
21 Document example:basic specifications vs C++ #ifndef _DOCUMENT_H_ #define _DOCUMENT_H_ #include <string> #include <vector> #include "paragraph.h" using std::string; using std::vector; class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: //! constructors with default parameters Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); // +all the relevant accessors!! (get / set) void append(paragraph&, bool); ; #endif document.h Programmation multi paradigmes en C++ 22
22 Document example:basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) : title(title), _authors(new_authors), _paragraphs(new_paragraphs), _external_paragraphs(new_external_paragraphs) Document::Document(const Document& d) _title = d._title; _authors = d._authors; _paragraphs = d._paragraphs; _external_paragraphs = d._external_paragraphs; document.cpp Programmation multi paradigmes en C++ 23
23 Document example:basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) : title(title), _authors(new_authors), _paragraphs(new_paragraphs), _external_paragraphs(new_external_paragraphs) Document::Document(const Document& d) _title = d._title; _authors = d._authors; _paragraphs = d._paragraphs; _external_paragraphs = d._external_paragraphs; Initialization style Versus assignment style! document.cpp Programmation multi paradigmes en C++ 24
24 Document example:basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool owned) if (owned == true) p.owner = this; _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp Programmation multi paradigmes en C++ 25
25 Document example:basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool owned) if (owned == true) p.owner = this; _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp Programmation multi paradigmes en C++ 26
26 Document example:basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool owned) if (owned == true) p.owner = this; _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp Programmation multi paradigmes en C++ 27
27 Document example:basic specifications vs C++ #include "document.h" /*! * There is nothing special here. */ Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; /*! append add a paragraph to this document. * \param _p Paragraph: the paragraph to add to the document * \param _owned boolean: if true, the paragraph is add to the document * as internal resource, otherwise, as external resource */ void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(paragraph(p)); else _external_paragraphs.push_back(&p); document.cpp Programmation multi paradigmes en C++ 28
28 Document example:basic specifications vs C++ class Paragraph private: string _title; string _content; Document* _owner; public: /*! constructors */ Paragraph(const Paragraph&); Paragraph(string t="default_title", string c=""); Paragraph(string, string, Document&); //... ; paragraph.h Programmation multi paradigmes en C++ 29
29 Document example:basic specifications vs C++ class Paragraph private: string _title; string _content; Document* _owner; public: Should we forbid construction /*! constructors */ of Paragraph with no owner? Paragraph(const Paragraph&); Paragraph(string t="default_title", string c=""); Paragraph(string, string, Document&); //... ; paragraph.h Programmation multi paradigmes en C++ 30
30 Document example:basic specifications vs C++ #ifndef _PARAGRAPH_H_ #define _PARAGRAPH_H_ #include <string> class Document; class Paragraph private: string _title; string _content; Document* _owner; public: /*! constructors */ Paragraph(const Paragraph&); Paragraph(string t="default_title", string c=""); //no owner to ease testing phase Paragraph(Document&, string t="default_title", string c=""); //... ; #endif paragraph.h Programmation multi paradigmes en C++ 31
31 Document example:basic specifications vs C++ #ifndef _PARAGRAPH_H_ #define _PARAGRAPH_H_ #include <string> #include <vector> class Document; class Paragraph private: string _title; string _content; Document* _owner; public: /*! constructors */ Paragraph(const Paragraph&); Paragraph(string t="default_title", string c=""); //no owner to ease testing phase Paragraph(Document&, string t="default_title", string c=""); //... ; Just says to the compiler that Document exists elsewhere #endif paragraph.h Programmation multi paradigmes en C++ 32
32 Document example:basic specifications vs C++ #include "paragraph.h" Paragraph::Paragraph(const Paragraph& p) :_title(p._title), _content(p._content), _owner(p._owner) Paragraph::Paragraph(string title, string content) :_title(title), _content(content), _owner(nullptr) Paragraph::Paragraph(Document& owner, string title, string content) :_title(title), _content(content), _owner(&owner) paragraph.cpp Programmation multi paradigmes en C++ 33
33 Document example:basic specifications vs C++ #include "paragraph.h" Paragraph::Paragraph(const Paragraph& p) :_title(p._title), _content(p._content), _owner(p._owner) Paragraph::Paragraph(string title, string content) :_title(title), _content(content), _owner(nullptr) Paragraph::Paragraph(Document& owner, string title, string content) :_title(title), _content(content), _owner(&owner) Paragraph::Paragraph(Document& owner, string title, string content) :Paragraph(title, content) _owner = &owner; Using constructor delegation //c++11 paragraph.cpp Programmation multi paradigmes en C++ 34
34 Document example:basic specifications vs C++ #include "paragraph.h" Paragraph::Paragraph(const Paragraph& p) :_title(p._title), _content(p._content), _owner(p._owner) Paragraph::Paragraph(string title, string content) :_title(title), _content(content), Different use of the '&' _owner(nullptr) Paragraph::Paragraph(Document& owner, string title, string content) :_title(title), _content(content), _owner(&owner) Paragraph::Paragraph(Document& owner, string title, string content) :Paragraph(title, content) _owner = &owner; Using constructor delegation //c++11 paragraph.cpp Programmation multi paradigmes en C++ 35
35 Document example:basic specifications vs C++ #include "document.h" int main(int argc, char* argv[]) /*paragraph creation*/ Paragraph p1"un titre","des trucs à lire... \n\t\t blablabla "; Paragraph p2"un autre titre","des trucs autre trucs"; Paragraph pext1"un titre externe","un paragraph externe"; /*author vector creation*/ vector<string> d1_authors"julien Deantoni"; d1_authors.push_back("jean-paul Rigault"); /*paragraph vector creation*/ vector<paragraph> d1_paragraphsp1; /*document creation*/ Document d1"nouveau Document", d1_authors, d1_paragraphs; /*add of an internal paragraph*/ d1.append(p2, true); //C++11 initializations /*add of an external paragraph*/ d1.append(pext1, false); return 0; main.cpp Programmation multi paradigmes en C++ 36
36 Document example:basic specifications vs C++ #include "document.h" int main(int argc, char* argv[]) /*paragraph creation*/ Paragraph p1 ="Un titre","des trucs à lire... \n\t\t blablabla "; Paragraph p2 = "Un autre titre","des trucs autre trucs"; Paragraph pext1 = "Un titre externe","un paragraph externe"; /*author vector creation*/ vector<string> d1_authors ="Julien Deantoni"; d1_authors.push_back("jean-paul Rigault"); /*paragraph vector creation*/ vector<paragraph> d1_paragraphs=p1; /*document creation*/ Document d1 ="Nouveau Document", d1_authors, d1_paragraphs; Document d1bis="nouveau Document", "Julien Deantoni","Jean-Paul Rigault", p1; /*add of an internal paragraph*/ d1.append(p2, true); //C++11 initializations /*add of an external paragraph*/ d1.append(pext1, false); return 0; main.cpp Programmation multi paradigmes en C++ 37
37 Document example:basic specifications vs C++ #include "document.h" int main(int argc, char* argv[]) /*paragraph creation*/ Paragraph p1 ="Un titre","des trucs à lire... \n\t\t blablabla "; Paragraph p2 = "Un autre titre","des trucs autre trucs"; Paragraph pext1 = "Un titre externe","un paragraph externe"; /*author vector creation*/ vector<string> d1_authors ="Julien Deantoni"; d1_authors.push_back("jean-paul Rigault"); //C++11 initializations /*paragraph vector creation*/ vector<paragraph> d1_paragraphs=p1; Without a printing function it is hard to know if it works fine /*document creation*/ Document d1 ="Nouveau Document", d1_authors, d1_paragraphs; Document d1bis="nouveau Document", "Julien Deantoni","Jean-Paul Rigault", p1; /*add of an internal paragraph*/ d1.append(p2, true); /*add of an external paragraph*/ d1.append(pext1, false); return 0; main.cpp Programmation multi paradigmes en C++ 38
38 Document example: operator overloading #ifndef _DOCUMENT_H_ #define _DOCUMENT_H_ #include <string> #include <vector> #include <iostream> #include "paragraph.h" class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: //... friend ostream& operator<<(ostream&, const Document&); ; #endif document.h Programmation multi paradigmes en C++ 39
39 Document example: operator overloading #include "document.h" //C++11 loops //... std::ostream& operator<<(std::ostream& os, const Document& d) os << d._title << " ("; for(const std::string author : d._authors) os << author << ' '; os << ")\n"; for (Paragraph& p : d._paragraphs) os << p; for (Paragraph* ptr_ep : d._external_paragraphs) os << *(ptr_ep); return os; document.cpp Programmation multi paradigmes en C++ 40
40 Document example: operator overloading #include "document.h" //C++11 loops //... std::ostream& operator<<(std::ostream& os, const Document& d) os << d._title << " ("; Deference of the pointer for(const std::string author : d._authors) os << author because << ' '; we want to print the paragraph, os << ")\n"; for (Paragraph& p : not d._paragraphs) the pointer os << p; for (Paragraph* ptr_ep : d._external_paragraphs) os << *(ptr_ep); return os; document.cpp Programmation multi paradigmes en C++ 41
41 Document example: operator overloading #include "document.h" //C++11 loops //... std::ostream& operator<<(std::ostream& os, const Document& d) os << d._title << " ("; for(const std::string& author : d._authors) os << author << ' '; os << ")\n"; for (Paragraph& p : d._paragraphs) os << p; for (Paragraph* ptr_ep : d._external_paragraphs) if (ptr_ep!= nullptr) os << *(ptr_ep); return os; document.cpp Programmation multi paradigmes en C++ 42
42 Document example: operator overloading #include "document.h" //C++11 loops //... std::ostream& operator<<(std::ostream& os, const Document& d) operator<< from os << d._title << " ("; Use of the the Paragraph class for(const std::string author : d._authors) os << author << ' '; os << ")\n"; for (Paragraph& p : d._paragraphs) os << p; for (Paragraph* ptr_ep : d._external_paragraphs) if (ptr_ep!= nullptr) os << *(ptr_ep); return os; Use of the operator<< from the Paragraph class document.cpp Programmation multi paradigmes en C++ 43
43 Document example: operator overloading #ifndef _PARAGRAPH_H_ #define _PARAGRAPH_H_ #include <string> #include <vector> #include <iostream> class Document; class Paragraph private: string _title; string _content; Document* _owner; public: //... ; friend ostream& operator<<(ostream&, const Paragraph&); #endif paragraph.h Programmation multi paradigmes en C++ 44
44 Document example: operator overloading #include "paragraph.h" //... ostream& operator<<(ostream& os, const Paragraph& p) os<< '\t' << p._title << \n << "\t\t" << p._content << endl; return os; paragraph.cpp Programmation multi paradigmes en C++ 45
45 Document example: operator overloading #include "document.h" int main(int argc, char* argv[]) /*paragraph creation*/ Paragraph p1="un titre","des trucs à lire... \n\t\t blablabla "; Paragraph p2="un autre titre","des trucs autre trucs"; Paragraph pext1="un titre externe","un paragraph externe"; /*author vector creation*/ vector<string> d1_authors="julien DeAntoni","Jean-Paul Rigault"; /*paragraph vector creation*/ vector<paragraph> d1_paragraphs=p1; /*document creation*/ Document d1("nouveau Document", d1_authors, d1_paragraphs); /*add of an internal paragraph*/ d1.append(p2, true); /*add of an external paragraph*/ d1.append(pext1, false); cout<<"******************************************************"<<endl; cout<< d1 << endl; return 1; main.cpp Programmation multi paradigmes en C++ 46
46 Document example: operator overloading #include "document.h" int main(int argc, char* argv[]) ****************************************************** Nouveau Document (Julien DeAntoni Jean-Paul Rigault) Un titre /*paragraph creation*/ Paragraph p1("un titre","des trucs à lire... \n\t\t blablabla "); Paragraph p2("un autre titre","des trucs autre trucs"); Paragraph pext1("un titre externe","un paragraph externe"); /*author vector creation*/ vector<string> d1_authors; des trucs à lire... d1_authors.push_back("julien DeAntoni"); d1_authors.push_back("jean-paul Rigault"); blablabla Un autre titre des trucs autre trucs Un titre externe un paragraph externe /*paragraph vector creation*/ vector<paragraph> d1_paragraphs; d1_paragraphs.push_back(p1); /*document creation*/ Document d1("nouveau Document", d1_authors, d1_paragraphs); /*add of an internal paragraph*/ d1.append(p2, true); /*add of an external paragraph*/ d1.append(pext1, false); cout<<"******************************************************"<<endl; cout<< d1 << endl; return 1; main.cpp Programmation multi paradigmes en C++ 47
47 Document example: Destructor Is there something to destroy?? Programmation multi paradigmes en C++ 48
48 Document example: Destructor Is there something to destroy?? It depends on the implementation... Programmation multi paradigmes en C++ 49
49 Document example: remember slide 8 class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", void append(paragraph&, bool); ; Note the difference between containment and association There are various points of view on this point. vector<string> new_authors= vector<string>(), You can choose your point of view but you will vector<paragraph> new_paragraphs=vector<paragraph>(), have motivate your choice. vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); For me, when there is a containment, the object life is under the responsibility of the container. Otherwise it is not. Programmation multi paradigmes en C++ 50
50 Document example: another implementation class Document private: string _title; vector<string> _authors; vector<paragraph*> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); void append(paragraph&, bool); ; Programmation multi paradigmes en C++ 51
51 Document example: another implementation #include "document.h" A new place is reserved in the memory and the corresponding pointer is put in the container void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); Programmation multi paradigmes en C++ 52
52 Document example: another implementation A new place is reserved in the memory and the corresponding pointer is put in the container #include "document.h" The previous statement is always true: For me, when there is a containment, the object life is under the responsibility of the container. Otherwise it is not. void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); Programmation multi paradigmes en C++ 53
53 Document example: another implementation void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); A new place is reserved in the memory and the corresponding pointer is putted in the container Document::~Document() for (Paragraph* ptr_p: paragraphs) delete ptr_p; The previous statement is always true: For me, when there is a containment, the object life is under the responsibility of the container. Otherwise it is not. Consequently, the release of the memory is handled in destructor Programmation multi paradigmes en C++ 54
54 Document example: another implementation void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); Document::~Document() for (Paragraph* ptr_p: paragraphs) delete ptr_p; The whole implementation must be consistent dynamic creation everywhere (copy constructor, assignment, etc)! A new place is reserved in the memory and the corresponding pointer is putted in the container The previous statement is always true: For me, when there is a containment, the object life is under the responsibility of the container. Otherwise it is not. Consequently, the release of the memory is handled in destructor Programmation multi paradigmes en C++ 55
55 Document example: operator overloading #include <string> #include <vector> #include <iostream> class Document; class Paragraph private: string _title; string _content; Document* _owner; public: //... //! assignment operator Paragraph& operator=(const Paragraph&); //! unary concatenation operator Paragraph& operator+=(const Paragraph&); //! binary concatenation operator friend Paragraph operator+(const Paragraph& p1, const Paragraph& p2); // and all the appropriate one... friend ostream& operator<<(ostream&, const Paragraph&); ; paragraph.h Programmation multi paradigmes en C++ 56
56 Document example: operator overloading //... Paragraph& Paragraph::operator=(const Paragraph& p) if (this == &p) return *this; this->_title = p._title; this->_content = p._content; this->_owner = p._owner; return *this; Paragraph& Paragraph::operator+=(const Paragraph& p) this->_title += (" / " + p._title); this->_content += p._content; return *this; class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; Looks like the copy constructor but no new object is created! We return (a reference on) the hidden argument (*this) Paragraph operator+(const Paragraph& p1, const Paragraph& p2) return Paragraph(p1._title+" / "+p2._title, p1._content + p2._content); paragraph.cpp Programmation multi paradigmes en C++ 57
57 Document example: operator overloading Paragraph& Paragraph::operator=(const Paragraph& p) if (this == &p) return *this; _title = string(p._title); _content = string(p._content); _owner = p._owner; return *this; /*! * operator +=, concatenate 'this' with another Paragraph. * \ref _title is merged with p._title and separate by a slash ('/') * \ref _content is simply merged with p._content without separation character * \param p the Paragraph to concatenate with this */ Paragraph& Paragraph::operator+=(const Paragraph& p) _title += (" / " + p._title); _content += p._content; return *this; A choice is done on what is the semantic of the concatenation documentation is important Paragraph operator+(const Paragraph& p1, const Paragraph& p2) return Paragraph(p1._title+" / "+p2._title, p1._content + p2._content); paragraph.cpp Programmation multi paradigmes en C++ 58
58 Document example: operator overloading Paragraph& Paragraph::operator=(const Paragraph& p) if (this == &p) return *this; _title = p._title; _content = p._content; _owner = p._owner; return *this; Paragraph& Paragraph::operator+=(const Paragraph& p) _title += (" / " + p._title); _content += p._content; return *this; /*! * operator +, concatenate two instances of Paragraph to create a new one. * \ref _title is merged with p._title and separate by a slash ('/') * \ref _content is simply merged with p._content without separation character * \param p1 the first Paragraph to merge * \param p2 the first Paragraph to merge * \return Paragraph the resulting Paragraph, i.e. the merged one */ Paragraph operator+(const Paragraph& p1, const Paragraph& p2) return Paragraph(p1._title+" / "+p2._title, p1._content + p2._content); paragraph.cpp Programmation multi paradigmes en C++ 59
59 Document example: operator overloading Paragraph& Paragraph::operator=(const Paragraph& p) if (this == &p) return *this; _title = string(p._title); _content = string(p._content); _owner = p._owner; return *this; Paragraph& Paragraph::operator+=(const Paragraph& p) _title += (" / " + p._title); _content += p._content; return *this; /*! Note that this is a friend function * operator +, concatenate two instances of Paragraph to create a new one. and not a member function * \ref _title is merged with p._title and separate by a slash ('/') * \ref _content is simply merged with p._content without separation character * \param p1 the first Paragraph to merge * \param p2 the first Paragraph to merge * \return Paragraph the resulting Paragraph, i.e. the merged one */ Paragraph operator+(const Paragraph& p1, const Paragraph& p2) return Paragraph(p1._title+" / "+p2._title, p1._content + p2._content); paragraph.cpp Programmation multi paradigmes en C++ 60
60 Document example: operator overloading class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: //! exception class class No_such_paragraph; ; //... friend ostream& operator<<(ostream&, const Document&); Paragraph& operator[](unsigned int n) throw(no_such_paragraph); #endif document.h Programmation multi paradigmes en C++ 61
61 Document example: operator overloading class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: //! exception class class No_such_paragraph; ; //... We should reuse existing out_of_range exception friend ostream& operator<<(ostream&, const Document&); Paragraph& operator[](unsigned int n) throw(no_such_paragraph); #endif document.h Programmation multi paradigmes en C++ 62
62 Document example: operator overloading //... Paragraph& Document::operator[](unsigned int n) throw(no_such_paragraph) if ( n >= (_paragraphs.size() + _external_paragraphs.size()) ) throw No_such_paragraph(); if ( n < _paragraphs.size() ) return _paragraphs.at(n); else return *(_external_paragraphs.at( n - _paragraphs.size() )); document.cpp Programmation multi paradigmes en C++ 63
63 Document example: operator overloading //... Paragraph& Document::operator[](unsigned int n) throw(no_such_paragraph) if ( n >= (_paragraphs.size() + _external_paragraphs.size()) ) throw No_such_paragraph(); if ( n < _paragraphs.size() ) return _paragraphs.at(n); else return *(_external_paragraphs.at( n - _paragraphs.size() )); document.cpp Programmation multi paradigmes en C++ 64
64 Document example: critics and problems What if an external_paragraphs is delete by its owner? No easy way to know it Can lead to a segmentation fault Require the use of smart pointer (not part of this course) What if we want to add chapter, section, sub-section,... What if we want to interleave internal and external chapters... Programmation multi paradigmes en C++ 65
65 Document example: critics and problems Need to update the owner each time a Paragraph is added into a document as owned! Document::Document(const Document& d) _title = d._title; _authors = d._authors; _paragraphs = d._paragraphs; _external_paragraphs = d._external_paragraphs; for(paragraph& p: _paragraphs) p.owner = this; Programmation multi paradigmes en C++ 66
66 Document example: critics and problems Need to update the owner each time a Paragraph is added into a document as owned! Document::Document(const Document& d) _title = d._title; _authors = d._authors; _paragraphs = d._paragraphs; _external_paragraphs = d._external_paragraphs; for(paragraph& p: _paragraphs) p.owner = this; Be sure to know why this reference! Programmation multi paradigmes en C++ 67
A <Basic> C++ Course. Julien DeAntoni. 7 - The document example. adapted from Jean-Paul Rigault courses
adapted from Jean-Paul Rigault courses 1 A C++ Course 7 - The document example Julien DeAntoni 2 This Week Just an example... 3 Document example: basic specifications Consider (unstructured) text
A <Basic> C++ Course
adapted from Jean-Paul Rigault courses 1 A C++ Course 7 Object-oriented programming Julien DeAntoni Outline Introduction to class derivation: variants of class Paragraph Dynamic typing and virtual
A <Basic> C++ Course
A C++ Course 7 Object-oriented programming Julien Deantoni adapted from Jean-Paul Rigault courses Outline Introduction to class derivation: variants of class Paragraph Dynamic typing and virtual
A <Basic> C++ Course
A C++ Course 5 Constructors / destructors operator overloading Julien Deantoni adapted from Jean-Paul Rigault courses This Week A little reminder Constructor / destructor Operator overloading Programmation
A <Basic> C++ Course
A C++ Course 5 Constructors / destructors operator overloading Julien DeAntoni adapted from Jean-Paul Rigault courses 1 2 This Week A little reminder Constructor / destructor Operator overloading
A <Basic> C++ Course
adapted from Jean-Paul Rigault courses 1 A C++ Course 8 Object-oriented programming 2 Julien Deantoni 2 Outline Dynamic Typing Truncature Cast 3 Variants of class Paragraph Definition of derived
Shahram Rahatlou. Computing Methods in Physics. Overloading Operators friend functions static data and methods
Overloading Operators friend functions static data and methods Shahram Rahatlou Computing Methods in Physics http://www.roma1.infn.it/people/rahatlou/cmp/ Anno Accademico 2018/19 Today s Lecture Overloading
pointers & references
pointers & references 1-22-2013 Inline Functions References & Pointers Arrays & Vectors HW#1 posted due: today Quiz Thursday, 1/24 // point.h #ifndef POINT_H_ #define POINT_H_ #include using
Review: C++ Basic Concepts. Dr. Yingwu Zhu
Review: C++ Basic Concepts Dr. Yingwu Zhu Outline C++ class declaration Constructor Overloading functions Overloading operators Destructor Redundant declaration A Real-World Example Question #1: How to
IS0020 Program Design and Software Tools Midterm, Fall, 2004
IS0020 Program Design and Software Tools Midterm, Fall, 2004 Name: Instruction There are two parts in this test. The first part contains 22 questions worth 40 points you need to get 20 right to get the
Lab 2: ADT Design & Implementation
Lab 2: ADT Design & Implementation By Dr. Yingwu Zhu, Seattle University 1. Goals In this lab, you are required to use a dynamic array to design and implement an ADT SortedList that maintains a sorted
Common Misunderstandings from Exam 1 Material
Common Misunderstandings from Exam 1 Material Kyle Dewey Stack and Heap Allocation with Pointers char c = c ; char* p1 = malloc(sizeof(char)); char** p2 = &p1; Where is c allocated? Where is p1 itself
CSI33 Data Structures
Outline Department of Mathematics and Computer Science Bronx Community College November 9, 2016 Outline Outline 1 Chapter 9: C++ Classes Outline Chapter 9: C++ Classes 1 Chapter 9: C++ Classes Class Syntax
CSE 333 Midterm Exam July 24, Name UW ID#
Name UW ID# There are 6 questions worth a total of 100 points. Please budget your time so you get to all of the questions. Keep your answers brief and to the point. The exam is closed book, closed notes,
Abstract Data Types (ADT) and C++ Classes
Abstract Data Types (ADT) and C++ Classes 1-15-2013 Abstract Data Types (ADT) & UML C++ Class definition & implementation constructors, accessors & modifiers overloading operators friend functions HW#1
C:\Temp\Templates. Download This PDF From The Web Site
11 2 2 2 3 3 3 C:\Temp\Templates Download This PDF From The Web Site 4 5 Use This Main Program Copy-Paste Code From The Next Slide? Compile Program 6 Copy/Paste Main # include "Utilities.hpp" # include
Homework 5. Yuji Shimojo CMSC 330. Instructor: Prof. Reginald Y. Haseltine
Homework 5 Yuji Shimojo CMSC 330 Instructor: Prof. Reginald Y. Haseltine July 13, 2013 Question 1 Consider the following Java definition of a mutable string class. class MutableString private char[] chars
Homework 4. Any questions?
CSE333 SECTION 8 Homework 4 Any questions? STL Standard Template Library Has many pre-build container classes STL containers store by value, not by reference Should try to use this as much as possible
CE221 Programming in C++ Part 1 Introduction
CE221 Programming in C++ Part 1 Introduction 06/10/2017 CE221 Part 1 1 Module Schedule There are two lectures (Monday 13.00-13.50 and Tuesday 11.00-11.50) each week in the autumn term, and a 2-hour lab
2 2
1 2 2 3 3 C:\Temp\Templates 4 5 Use This Main Program 6 # include "Utilities.hpp" # include "Student.hpp" Copy/Paste Main void MySwap (int Value1, int Value2); int main(int argc, char * argv[]) { int A
Linked List using a Sentinel
Linked List using a Sentinel Linked List.h / Linked List.h Using a sentinel for search Created by Enoch Hwang on 2/1/10. Copyright 2010 La Sierra University. All rights reserved. / #include
CSCE 110 PROGRAMMING FUNDAMENTALS
CSCE 110 PROGRAMMING FUNDAMENTALS WITH C++ Prof. Amr Goneid AUC Part 15. Dictionaries (1): A Key Table Class Prof. amr Goneid, AUC 1 Dictionaries(1): A Key Table Class Prof. Amr Goneid, AUC 2 A Key Table
ADTs & Classes. An introduction
ADTs & Classes An introduction Quick review of OOP Object: combination of: data structures (describe object attributes) functions (describe object behaviors) Class: C++ mechanism used to represent an object
Inheritance and Polymorphism
Inheritance and Polymorphism 1 Inheritance extending a clock to an alarm clock deriving a class 2 Polymorphism virtual functions and polymorphism abstract classes MCS 360 Lecture 8 Introduction to Data
CSE 333. Lecture 10 - references, const, classes. Hal Perkins Paul G. Allen School of Computer Science & Engineering University of Washington
CSE 333 Lecture 10 - references, const, classes Hal Perkins Paul G. Allen School of Computer Science & Engineering University of Washington Administrivia New C++ exercise out today, due Friday morning
III. Classes (Chap. 3)
III. Classes III-1 III. Classes (Chap. 3) As we have seen, C++ data types can be classified as: Fundamental (or simple or scalar): A data object of one of these types is a single object. int, double, char,
CS 215 Fundamentals of Programming II Spring 2018 Project 5
CS 215 Fundamentals of Programming II Spring 2018 Project 5 30 points Out: March 23, 2018 Due: April 9, 2018 (Monday) As explained in Project 3, a line editor is a text editor that operates on lines of
CS 211 Winter 2004 Sample Final Exam (Solutions)
CS 211 Winter 2004 Sample Final Exam (Solutions) Instructor: Brian Dennis, Assistant Professor TAs: Tom Lechner, Rachel Goldsborough, Bin Lin March 16, 2004 Your Name: There are 6 problems on this exam.
Fast Introduction to Object Oriented Programming and C++
Fast Introduction to Object Oriented Programming and C++ Daniel G. Aliaga Note: a compilation of slides from Jacques de Wet, Ohio State University, Chad Willwerth, and Daniel Aliaga. Outline Programming
EINDHOVEN UNIVERSITY OF TECHNOLOGY Department of Mathematics and Computer Science
EINDHOVEN UNIVERSITY OF TECHNOLOGY Department of Mathematics and Computer Science Written examination Homologation C++ and Computer Organization (2DMW00) Part I: C++ - on Tuesday, November 1st 2016, 9:00h-12:00h.
Program template-smart-pointers-again.cc
1 // Illustrate the smart pointer approach using Templates 2 // George F. Riley, Georgia Tech, Spring 2012 3 // This is nearly identical to the earlier handout on smart pointers 4 // but uses a different
Operator Overloading in C++ Systems Programming
Operator Overloading in C++ Systems Programming Operator Overloading Fundamentals of Operator Overloading Restrictions on Operator Overloading Operator Functions as Class Members vs. Global Functions Overloading
OBJECT ORIENTED PROGRAMMING USING C++
OBJECT ORIENTED PROGRAMMING USING C++ Overview of C++ Overloading Overloading occurs when the same operator or function name is used with different signatures Both operators and functions can be overloaded
Due Date: See Blackboard
Source File: ~/2315/11/lab11.(C CPP cpp c++ cc cxx cp) Input: Under control of main function Output: Under control of main function Value: 1 The purpose of this assignment is to become more familiar with
Review. What is const member data? By what mechanism is const enforced? How do we initialize it? How do we initialize it?
Review Describe pass-by-value and pass-by-reference Why do we use pass-by-reference? What does the term calling object refer to? What is a const member function? What is a const object? How do we initialize
Overloaded Operators, Functions, and Students
, Functions, and Students Division of Mathematics and Computer Science Maryville College Outline Overloading Symbols 1 Overloading Symbols 2 3 Symbol Overloading Overloading Symbols A symbol is overloaded
Financial computing with C++
Financial Computing with C++, Lecture 4 - p1/19 Financial computing with C++ LG Gyurkó University of Oxford Michaelmas Term 2015 Financial Computing with C++, Lecture 4 - p2/19 Outline General properties
Outline. 1 Function calls and parameter passing. 2 Pointers, arrays, and references. 5 Declarations, scope, and lifetimes 6 I/O
Outline EDAF30 Programming in C++ 2. Introduction. More on function calls and types. Sven Gestegård Robertz Computer Science, LTH 2018 1 Function calls and parameter passing 2 Pointers, arrays, and references
Due Date: See Blackboard
Source File: ~/2315/45/lab45.(C CPP cpp c++ cc cxx cp) Input: under control of main function Output: under control of main function Value: 4 Integer data is usually represented in a single word on a computer.
COMP6771 Advanced C++ Programming
1.. COMP6771 Advanced C++ Programming Week 5 Part Two: Dynamic Memory Management 2016 www.cse.unsw.edu.au/ cs6771 2.. Revisited 1 #include 2 3 struct X { 4 X() { std::cout
EECE.3220: Data Structures Spring 2017
EECE.3220: Data Structures Spring 2017 Lecture 14: Key Questions February 24, 2017 1. Describe the characteristics of an ADT to store a list. 2. What data members would be necessary for a static array-based
PIC 10A Objects/Classes
PIC 10A Objects/Classes Ernest Ryu UCLA Mathematics Last edited: November 13, 2017 User-defined types In C++, we can define our own custom types. Object is synonymous to variable, and class is synonymous
Financial computing with C++
Financial Computing with C++, Lecture 6 - p1/24 Financial computing with C++ LG Gyurkó University of Oxford Michaelmas Term 2015 Financial Computing with C++, Lecture 6 - p2/24 Outline Linked lists Linked
Abstract Data Types (ADTs) 1. Legal Values. Client Code for Rational ADT. ADT Design. CS 247: Software Engineering Principles
Abstract Data Types (ADTs) CS 247: Software Engineering Principles ADT Design An abstract data type (ADT) is a user-defined type that bundles together: the range of values that variables of that type can
Ch. 12: Operator Overloading
Ch. 12: Operator Overloading Operator overloading is just syntactic sugar, i.e. another way to make a function call: shift_left(42, 3); 42
Function Overloading
Function Overloading C++ supports writing more than one function with the same name but different argument lists How does the compiler know which one the programmer is calling? They have different signatures
CS 247: Software Engineering Principles. ADT Design
CS 247: Software Engineering Principles ADT Design Readings: Eckel, Vol. 1 Ch. 7 Function Overloading & Default Arguments Ch. 12 Operator Overloading U Waterloo CS247 (Spring 2017) p.1/17 Abstract Data
Classes in C++98 and C++11
Classes in C++98 and C++11 January 10, 2018 Brian A. Malloy Slide 1 of 38 1. When we refer to C++98, we are referring to C++98 and C++03, since they differ only slightly. C++98 contained 3 types of constructors,
Distributed Real-Time Control Systems. Lecture 17 C++ Programming Intro to C++ Objects and Classes
Distributed Real-Time Control Systems Lecture 17 C++ Programming Intro to C++ Objects and Classes 1 Bibliography Classical References Covers C++ 11 2 What is C++? A computer language with object oriented
Object-Oriented Programming, Iouliia Skliarova
Object-Oriented Programming, Iouliia Skliarova CBook a = CBook("C++", 2014); CBook b = CBook("Physics", 1960); a.display(); b.display(); void CBook::Display() cout
2 ADT Programming User-defined abstract data types
Preview 2 ADT Programming User-defined abstract data types user-defined data types in C++: classes constructors and destructors const accessor functions, and inline functions special initialization construct
Reference Parameters A reference parameter is an alias for its corresponding argument in the function call. Use the ampersand (&) to indicate that
Reference Parameters There are two ways to pass arguments to functions: pass-by-value and pass-by-reference. pass-by-value A copy of the argument s value is made and passed to the called function. Changes
Modern C++ for Computer Vision and Image Processing. Igor Bogoslavskyi
Modern C++ for Computer Vision and Image Processing Igor Bogoslavskyi Outline Move semantics Classes Operator overloading Making your class copyable Making your class movable Rule of all or nothing Inheritance
Unified Modeling Language a case study
Unified Modeling Language a case study 1 an online phone book use case diagram encapsulating a file 2 Command Line Arguments arguments of main arrays of strings 3 Class Definition the filesphonebook.h
COMP 2355 Introduction to Systems Programming
COMP 2355 Introduction to Systems Programming Christian Grothoff christian@grothoff.org http://grothoff.org/christian/ 1 Today Class syntax, Constructors, Destructors Static methods Inheritance, Abstract
ECE Fall 20l2, Second Exam
ECE 30862 Fall 20l2, Second Exam DO NOT START WORKING ON THIS UNTIL TOLD TO DO SO. LEAVE IT ON THE DESK. You have until 12:20 to take this exam. Your exam should have 16 pages total (including this cover
Set Implementation Version 1
Introduction to System Programming 234122 Set Implementation Version 1 Masha Nikolski, CS Department, Technion 1 // Version 1.0 2 // Header file for set class. 3 // In this implementation set is a container
Structuur van Computerprogramma s 2
Structuur van Computerprogramma s 2 dr. Dirk Deridder Dirk.Deridder@vub.ac.be http://soft.vub.ac.be/ Vrije Universiteit Brussel - Faculty of Science and Bio-Engineering Sciences - Computer Science Department
Object Oriented Design
Object Oriented Design Chapter 9 Initializing a non-static data member in the class definition is a syntax error 1 9.2 Time Class Case Study In Fig. 9.1, the class definition is enclosed in the following
Introduction to Computers and C++ Programming p. 1 Computer Systems p. 2 Hardware p. 2 Software p. 7 High-Level Languages p. 8 Compilers p.
Introduction to Computers and C++ Programming p. 1 Computer Systems p. 2 Hardware p. 2 Software p. 7 High-Level Languages p. 8 Compilers p. 9 Self-Test Exercises p. 11 History Note p. 12 Programming and
A <Basic> C++ Course. 12 lambda expressions and concurrency in C++11. Julien Deantoni
A C++ Course 12 lambda expressions and concurrency in C++11 Julien Deantoni Lambda expressions A unnamed function (which is a std::function) Usable in many place like algorithms, thread, [capture](parameters)->return-type
Object oriented programming
Exercises 12 Version 1.0, 9 May, 2017 Table of Contents 1. Virtual destructor and example problems...................................... 1 1.1. Virtual destructor.......................................................
C++ Review. CptS 223 Advanced Data Structures. Larry Holder School of Electrical Engineering and Computer Science Washington State University
C++ Review CptS 223 Advanced Data Structures Larry Holder School of Electrical Engineering and Computer Science Washington State University 1 Purpose of Review Review some basic C++ Familiarize us with
Object-Oriented Design (OOD) and C++
Chapter 2 Object-Oriented Design (OOD) and C++ At a Glance Instructor s Manual Table of Contents Chapter Overview Chapter Objectives Instructor Notes Quick Quizzes Discussion Questions Projects to Assign
Makefiles Makefiles should begin with a comment section of the following form and with the following information filled in:
CS 215 Fundamentals of Programming II C++ Programming Style Guideline Most of a programmer's efforts are aimed at the development of correct and efficient programs. But the readability of programs is also
G52CPP C++ Programming Lecture 9
G52CPP C++ Programming Lecture 9 Dr Jason Atkin http://www.cs.nott.ac.uk/~jaa/cpp/ g52cpp.html 1 Last lecture const Constants, including pointers The C pre-processor And macros Compiling and linking And
Outline. User-dened types Categories. Constructors. Constructors. 4. Classes. Concrete classes. Default constructor. Default constructor
Outline EDAF50 C++ Programming 4. Classes Sven Gestegård Robertz Computer Science, LTH 2018 1 Classes the pointer this const for objects and members Copying objects friend inline 4. Classes 2/1 User-dened
Lecture 2. Binary Trees & Implementations. Yusuf Pisan
CSS 343 Data Structures, Algorithms, and Discrete Math II Lecture 2 Binary Trees & Implementations Yusuf Pisan Overview 1. Huffman Coding and Arithmetic Expressions 2. 342 Topics a. Pointers & References
Program template-smart-pointers.cc
1 // Illustrate the smart pointer approach using Templates 2 // George F. Riley, Georgia Tech, Spring 2012 3 4 #include 5 #include 6 7 using namespace std; 8 9 // The Ptr class contains
Intermediate Programming & Design (C++) Classes in C++
Classes in C++ A class is a data type similar to a C structure. It includes various local data (called data members) together with constructors, destructors and member functions. All of them are called
CpSc212 Goddard Notes Chapter 10. Linked Lists
CpSc212 Goddard Notes Chapter 10 Linked Lists 10.1 Links and Pointers The linked list is not an ADT in its own right; rather it is a way of implementing many data structures. It is designed to replace
Problem Solving with C++
GLOBAL EDITION Problem Solving with C++ NINTH EDITION Walter Savitch Kendrick Mock Ninth Edition PROBLEM SOLVING with C++ Problem Solving with C++, Global Edition Cover Title Copyright Contents Chapter
LECTURE 03 LINKED LIST
DATA STRUCTURES AND ALGORITHMS LECTURE 03 LINKED LIST IMRAN IHSAN ASSISTANT PROFESSOR AIR UNIVERSITY, ISLAMABAD LINKED LISTS DEFINITION A linked list is a data structure where each object is stored in
Comp151. Generic Programming: Container Classes
Comp151 Generic Programming: Container Classes Container Classes Container classes are a typical use for class templates, since we need container classes for objects of many different types, and the types
Operator overloading
1 Introduction 2 The copy constructor 3 Operator Overloading 4 Eg 1: Adding two vectors 5 The -> operator 6 The this pointer 7 Overloading = 8 Unary operators 9 Overloading for the matrix class 10 The
CSE 333 Midterm Exam July 24, 2017 Sample Solution
Sample Solution Question 1. (14 points) Making things. Suppose we have the following C header and implementation files, showing the various #include and #if directives in each one: widget.h #ifndef _WIDGET_H_
Evolution of Programming Languages
Evolution of Programming Languages 40's machine level raw binary 50's assembly language names for instructions and addresses very specific to each machine 60's high-level languages: Fortran, Cobol, Algol,
Structuur van Computerprogramma s 2
Structuur van Computerprogramma s 2 dr. Dirk Deridder Dirk.Deridder@vub.ac.be http://soft.vub.ac.be/ Vrije Universiteit Brussel - Faculty of Science and Bio-Engineering Sciences - Computer Science Department
Abstraction and Encapsulation. Benefits of Abstraction & Encapsulation. Concrete Types. Using Typedefs to streamline classes.
Classes II: Type Conversion,, For : COP 3330. Object oriented Programming (Using C++) http://www.compgeom.com/~piyush/teach/3330 Abstraction and Encapsulation Abstraction: Separation of interface from
G52CPP C++ Programming Lecture 13
G52CPP C++ Programming Lecture 13 Dr Jason Atkin http://www.cs.nott.ac.uk/~jaa/cpp/ g52cpp.html 1 Last lecture Function pointers Arrays of function pointers Virtual and non-virtual functions vtable and
AN OVERVIEW OF C++ 1
AN OVERVIEW OF C++ 1 OBJECTIVES Introduction What is object-oriented programming? Two versions of C++ C++ console I/O C++ comments Classes: A first look Some differences between C and C++ Introducing function
Slide Set 14. for ENCM 339 Fall Steve Norman, PhD, PEng. Electrical & Computer Engineering Schulich School of Engineering University of Calgary
Slide Set 14 for ENCM 339 Fall 2016 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary November 2016 ENCM 339 Fall 2016 Slide Set 14 slide 2/35
Intermediate Programming, Spring 2017*
600.120 Intermediate Programming, Spring 2017* Misha Kazhdan *Much of the code in these examples is not commented because it would otherwise not fit on the slides. This is bad coding practice in general
A class is a user-defined type. It is composed of built-in types, other user-defined types and
Chapter 3 User-defined types 3.1 Classes A class is a user-defined type. It is composed of built-in types, other user-defined types and functions. The parts used to define the class are called members.
CSCI 123 Introduction to Programming Concepts in C++
CSCI 123 Introduction to Programming Concepts in C++ Brad Rippe Brad Rippe More Classes and Dynamic Arrays Overview 11.4 Classes and Dynamic Arrays Constructors, Destructors, Copy Constructors Separation
Where do we go from here?
Where do we go from here? C++ classes and objects, with all the moving parts visible operator overloading templates, STL, standards, Java components, collections, generics language and performance comparisons
ECE 462 Fall 2011, Second Exam
ECE 462 Fall 2011, Second Exam DO NOT START WORKING ON THIS UNTIL TOLD TO DO SO. You have until 9:20 to take this exam. Your exam should have 10 pages total (including this cover sheet). Please let Prof.
CSS 342 Data Structures, Algorithms, and Discrete Mathematics I. Lecture 2. Yusuf Pisan
CSS 342 Data Structures, Algorithms, and Discrete Mathematics I Lecture 2 Yusuf Pisan Compiled helloworld yet? Overview C++ fundamentals Assignment-1 CSS Linux Cluster - submitting assignment Call by Value,
CPSC 427: Object-Oriented Programming
CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 7 September 21, 2016 CPSC 427, Lecture 7 1/21 Brackets Example (continued) Storage Management CPSC 427, Lecture 7 2/21 Brackets Example
A <Basic> C++ Course
A C++ Course 6 Fonctions et classes templates Julien Deantoni adapted from Jean-Paul Rigault courses 1 2 Pointers and references References vs. pointers References and pointers A reference must
Use the dot operator to access a member of a specific object.
Lab 16 Class A class is a data type that can contain several parts, which are called members. There are two types of members, data member and functions. An object is an instance of a class, and each object
Instantiation of Template class
Class Templates Templates are like advanced macros. They are useful for building new classes that depend on already existing user defined classes or built-in types. Example: stack of int or stack of double
Operator Overloading
Steven Zeil November 4, 2013 Contents 1 Operators 2 1.1 Operators are Functions.... 2 2 I/O Operators 4 3 Comparison Operators 6 3.1 Equality Operators....... 11 3.2 Less-Than Operators...... 13 1 1 Operators
RECOMMENDATION. Don't Write Entire Programs Unless You Want To Spend 3-10 Times As Long Doing Labs! Write 1 Function - Test That Function!
1 2 RECOMMENDATION Don't Write Entire Programs Unless You Want To Spend 3-10 Times As Long Doing Labs! Write 1 Function - Test That Function! 2 Function Overloading C++ provides the capability of Using
Introduction to Classes
Introduction to Classes Procedural and Object-Oriented Programming Procedural and Object-Oriented Programming Procedural programming focuses on the process/actions that occur in a program Object-Oriented
G52CPP C++ Programming Lecture 14. Dr Jason Atkin
G52CPP C++ Programming Lecture 14 Dr Jason Atkin 1 Last Lecture Automatically created methods: A default constructor so that objects can be created without defining a constructor A copy constructor used
Lecture Notes CPSC 224 (Spring 2012) Today... Java basics. S. Bowers 1 of 8
Today... Java basics S. Bowers 1 of 8 Java main method (cont.) In Java, main looks like this: public class HelloWorld { public static void main(string[] args) { System.out.println("Hello World!"); Q: How
Advanced Systems Programming
Advanced Systems Programming Introduction to C++ Martin Küttler September 19, 2017 1 / 18 About this presentation This presentation is not about learning programming or every C++ feature. It is a short
EX3 Code Review. Instructor: Tsung-Che Chiang
EX3 Code Review Instructor: Tsung-Che Chiang tcchiang@ieee.org Department of Computer Science and Information Engineering National Taiwan Normal University The Practice of Programming, CSIE@NTNU, Fall,
Exam duration: 3 hours Number of pages: 10
INFOMGEP 2011 Retake exam Student name: Student number: Exam duration: 3 hours Number of pages: 10 All the answers have to be written in the corresponding boxes. It is allowed to have: - lecture notes