C++ ProgrammingLaajuus (3 op)
Tunnus: TT00CB04
Laajuus
3 op
Vastuuhenkilö
- Janne Salonen
Osaamistavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2024 - 31.07.2024
Ajoitus
01.08.2024 - 31.07.2025
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ajoitus
16.04.2024 - 31.12.2025
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_2025_MAKSULLINEN_JARJESTELMAVIOPE 2025 MAKSULLINEN JARJESTELMA
-
VIOPE_2024_MAKSULLINEN_JARJESTELMAViope TiVi (NonStop), vuosi 2024
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.01.2024 - 31.07.2025
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_2024_MAKSULLINEN_JARJESTELMAViope TiVi (NonStop), vuosi 2024
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.01.2024 - 31.07.2025
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_2024_MAKSULLINEN_JARJESTELMAViope TiVi (NonStop), vuosi 2024
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2024 - 31.07.2024
Ajoitus
01.01.2024 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop6VIOPE_NonStop6
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2024 - 31.07.2024
Ajoitus
01.01.2024 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Ryhmät
-
Viope_nonstop_9Viope_nonstop_9
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2024 - 31.07.2024
Ajoitus
01.01.2024 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Ryhmät
-
Viope_nonstop_11Viope_nonstop_11
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2024 - 31.07.2024
Ajoitus
01.01.2024 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Ryhmät
-
Viope_nonstop_12Viope_nonstop_12
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2023 - 31.07.2023
Ajoitus
01.08.2023 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Toimipiste
Karaportti 2
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ilmoittautumisaika
02.07.2023 - 31.07.2023
Ajoitus
01.08.2023 - 31.07.2024
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Toimipiste
Karaportti 2
Opetuskielet
- Suomi
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Janne Salonen
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ajoitus
01.08.2023 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
ATX22TV_Study_PackagesAvoin amk: NonStop opintopaketit
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop3VIOPE_NonStop3
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop4VIOPE_NonStop4
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop4VIOPE_NonStop4
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop5VIOPE_NonStop5
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
02.11.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop3VIOPE_NonStop3
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
02.11.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop4VIOPE_NonStop4
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
02.11.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop4VIOPE_NonStop4
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
02.11.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop5VIOPE_NonStop5
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
01.08.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
- Virve Prami
Vastuuopettaja
Janne Salonen
Ryhmät
-
VIOPE_NonStop7VIOPE_NonStop7
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
31.07.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop3VIOPE_NonStop3
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
24.05.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop3VIOPE_NonStop3
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
24.05.2022 - 31.12.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE_NonStop3VIOPE_NonStop3
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS Student via https://hakija.oma.metropolia.fi/
CampusOnline Students via eform which can be find via https://campusonline.fi
Metropolia's Degree Student
- Go to https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop).
- Fill the others fields
If you have problems with enrolling this course or questions about it, please contact to viopesupport@metropolia.fi
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ilmoittautumisaika
11.02.2022 - 21.03.2022
Ajoitus
13.03.2022 - 31.07.2022
Opintopistemäärä
3 op
Toteutustapa
Lähiopetus
Yksikkö
ICT ja tuotantotalous
Opetuskielet
- Suomi
Vastuuopettaja
Janne Salonen
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Arviointiasteikko
0-5
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Lisätiedot
Online course
Ajoitus
28.02.2022 - 06.08.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
ATX22TVKAvoin amk: NonStop kevät 2022
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
10.01.2022 - 31.12.2023
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 1000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Vastuuopettaja
Janne Salonen
Ryhmät
-
CareerBoost_TXK_21Career Boost 21 (Tivi)
-
CBAB22KCAREERBOOST_K22-S22_TXJ Automaatiobisnes
-
CareerBoost_TXK_22Career Boost 22 (TiVi)
-
CBAB21SCAREERBOOST_S21-K22_AB
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
03.11.2021 - 27.02.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
ATX22TVKAvoin amk: NonStop kevät 2022
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course
Ajoitus
12.11.2020 - 31.07.2022
Opintopistemäärä
3 op
Virtuaaliosuus
3 op
Toteutustapa
Etäopetus
Yksikkö
ICT ja tuotantotalous
Toimipiste
Karaportti 2
Opetuskielet
- Englanti
Paikat
0 - 5000
Koulutus
- Tieto- ja viestintätekniikan tutkinto-ohjelma
Opettaja
- Mika Hyyryläinen
Ryhmät
-
VIOPE2021Maksullinen järjestelmä Viope 2021
Tavoitteet
The student is familiar with C++ language and its specific features in object-oriented programming. The student knows how to define a class, instantiate it and write code, in which the objets created are used. The student knows how to make objects interact with each other, how to use inheritance and how to use dynamic binding.
The student knows how to define and use generic functions and classes as well as operator functions
Sisältö
- automatic and dynamic creation of an object,
- constructors and destructors,
- inheritance, associations, aggregation,
- function overloading,
- virtual functions and dynamic binding,
- various parameter types,
- copy constructor,
- operator overloading,
- generic classes and functions,
- standard class library.
Aika ja paikka
Riippuu opiskelijasta itsestään.
Oppimateriaalit
Löytyy oppimisympäristöstä.
Opetusmenetelmät
100% netin kautta itsenäisesti suoritettava kurssi.
Harjoittelu- ja työelämäyhteistyö
N/A
Tenttien ajankohdat ja uusintamahdollisuudet
N/A
Kansainvälisyys
N/A
Toteutuksen valinnaiset suoritustavat
N/A
Opiskelijan ajankäyttö ja kuormitus
Riippuu opiskelijan lähtötasosta.
Sisällön jaksotus
Riippuu opiskelijasta itsestään.
Lisätietoja opiskelijoille
ENROLLING
Open UAS and CampusOnline Student: Please fill in eform
Metropolia's Degree Student: https://vw4.viope.com/login?org=metropolia
- Register to system -> Click the link “Enroll on the course”
- Choose any course of (NonStop)
- Fill the others fields
Arviointiasteikko
Hyväksytty/Hylätty
Arviointikriteerit, tyydyttävä (1)
After completing this course the student will
- understand the difference between a class and an object and knows how to use straightforward pre-coded classes in a software application
- understands why classes are generally speaking necessary and how they are used (the importance of differentiating between implementation and user interface)
- is able to design and use simple classes
- understands the goal of making classes to be applicable for multiple purposes
- understands how the vector class model operates and knows how to correctly use it instead of a C language array
Arviointikriteerit, hyvä (3)
After completing this course the student will
- understand the benefits and disadvantages of dynamic memory management when designing and using objects
- when designing classes understand and be prepared for the challenges brought by any dynamic data members (need for a destructor, need for a copy constructor, need for an assignment operator etc.)
- knows how to select a suitable class relation type (inheritance, association, aggregation) according to the situation when using an existing class to implement a new class
- also knows how to implement a new class using the class relation types mentioned above
- understands the implementation differences between various STL container class models thus being able to select a suitable model based on the requirements of the current application
Arviointikriteerit, kiitettävä (5)
After completing this course the student will
- deeply understand the meaning of function models and class models and how these operate on the compiler level
- knows when designing classes how to be prepared for eventual memory leaks and knows how to prevent these leaks in all situations (exceptional situations included)
- is able to very expertly use pointers, not just by trial and error (defining a pointer, indirect referencing, using references)
Arviointimenetelmät ja arvioinnin perusteet
Kun olet tehnyt 80% tehtävistä, niin kurssiarvioinnin saamiseksi sinun tulee lähettää sähköpostiviestiä osoitteeseen: viopesupport@metropolia.fi
Lisätiedot
Online course