introduction c++ .net advanced c# c# 4 collections algorithms linq c# 3 c# 2 polymorphism namespaces abstraction office course c# syntax cornerstones excel iterators reflection delegates and events custom attributes object-based and generic collections error handling with exceptions enums assemblies value types and reference types abstract types when to use inheritance sealed types interfaces static and dynamic type of objects "is-a" and "has-a" relationship methods simulation of reality fields specialization and generalization constructors classes unified modeling language (uml) name mangling and application binary interfaces (a compile time and link time dependencies with udts modularization using types in size and using types static and dynamic linked libraries internal and external linkage how to reduce compile time dependencies problems with preprocessor macros separate compilation the preprocessor – symbols and macros including and #include guards the one definition rule (odr) the make system translation units the assert() macro inheritance: generalization – specialization ass problem of pasta-object-oriented architecture the dependency inversion principle aggregation: whole – part associations object slicing and the extra layer of indirection non-public inheritance overriding and hiding dealing with specialized behavior the substitution principle unified modeling language (uml) basics non-member function operators and friends the output operator comparison operators and equivalence equality operators lvalues and c++11 rvalues the copy-operator= the stl type std::string const member functions type conversion c++ references and const references const correctness temporary and anonymous objects mutable fields copy constructors const-ness in c++ destructors and resource acquisition is initializa advanced creation of instances on the heap and the copies of objects and avoiding copying objects controlling the lifetime of an object the operators new/delete instance- vs. class members new[]/delete[] and placement naming conventions constructors and default constructors concepts of object-orientation: abstraction and en inline member functions restricting access to members abstracted types with member functions encapsulation with classes static versus automatic storage classes introducing cpu registers stack overflow c/c++ calling conventions function call stacks function stack frames and the decrementing stack the static storage class and the data segment how variable argument lists work with the stack the stack pointer and the base pointer underflow and channelling incl. examples array addressing with "cast contact lenses" the teddybear principle the heap: segmentation and "why do programs crash? the octal and hexadecimal numeral system memory representation of arrays and pointer arithm byte order how to understand and fix bugs bitwise integral operations floaty <-> integral conversion and reinterpreta numeric representation of fractional numbers in so the decimal numeral system c/c++ integral conversion in memory numeric representation of integers in software mathematical number systems revisited integer overflow in memory and integer division dynamic memory and dynamic array allocation concatenation and formatting lost pointers and memory leaks automatic versus dynamic arrays "geometric" properties of the heap and the stack a glimpse of the topic "stack versus heap" advanced c-strings: buffers basic c-string functions pointers arrays and pointer decay c-strings as arrays and their memory representatio automatic arrays pointers to pointers separated function definitions functions recursion fundamental types constants evaluation order associativity control structures precedence operators memory representation alignment html5 canvas browser plugins events polling interactivity gui xerox apple terminal mainframe k hosting scripting languages home-brew dynamic dispatch expando objects in c# dynamic objects in javascript dynamic com automation with c# duck typing and consistency dynamic language runtime (dlr) basics dynamic programming in vb and c#4 why dynamic programming > tuple<t generic variance lazy<t> improvements in code generation working with com pitfalls joins and subqueries) tips grouping aggregation advanced query expressions (ordering optimization extension methods on ienumerable<t> deferred execution algorithms in c#3 lambda expressions extension methods implicit typing automatically implemented properties object and collection initializers: new ways to in nullable types anonymous methods methods and method groups variance of delegates delegates generic types static classes separate getter/setter property access modifiers dissection of the .net 1 type system tour through other .net programming languages presentation techniques materials: perception and visualization successful presentation getting information and handling sources ganzheitliche handlungskompetenz personal impression of the presenter route of a presentation tuples as pseudo collections filling collections with structured data collections abstracting data processing: stack and immutable collections and defense copies producing collection objects empty collections kung fu beyond collections: .net's linq and java's set-like associative collections bst-based implementation implementation strategies of map/dictionary-like a multimaps equality hashtable-based implementation a 20k miles perspective on trees in computer scien sequential and associative collections object-based vs. generic collections equivalence-based associative collections: .net's associative collections operations on .net's idictionarys comparison and implementation of .net's interfaces generics types in java an interface-based approach the dependency inversion principle (dip) ordered and unordered collections sequential collections – linked lists pattern matching in functional programming languag arrays revisited value and reference semantics of elements size and capacity lists indexed collections a way to categorize collections divide and conquer complexity and o-notation mergesort and quicksort analysis of sorting algorithms selection-sort and insertion-sort algorithmic complexity analysis of algorithms’ costs abstract types with pure virtual member functions virtual destructors run time type identification (rtti) and dynamic_ca protected members c++11: explicit overrides and final methods (c++11: the "rule of five") the "rule of three" polynome mathematische funktionen formatting excel history nullstellen normalparabel quadratische gleichungssysteme lineare gleichchungssysteme graph wertetabellen function cellrelations basic query expressions (projection and selection) anonymous types introducing linq to objects (c++11: the rule of five) the rule of three bjarne stroustrup
Mehr anzeigen