Презентация The Essence of C with examples in C84, C98, C11, and C14 онлайн
На нашем сайте вы можете скачать и просмотреть онлайн доклад-презентацию на тему The Essence of C with examples in C84, C98, C11, and C14 абсолютно бесплатно. Урок-презентация на эту тему содержит всего 65 слайдов. Все материалы созданы в программе PowerPoint и имеют формат ppt или же pptx. Материалы и темы для презентаций взяты из открытых источников и загружены их авторами, за качество и достоверность информации в них администрация сайта не отвечает, все права принадлежат их создателям. Если вы нашли то, что искали, отблагодарите авторов - поделитесь ссылкой в социальных сетях, а наш сайт добавьте в закладки.
Презентации » Устройства и комплектующие » The Essence of C with examples in C84, C98, C11, and C14
Оцените!
Оцените презентацию от 1 до 5 баллов!
- Тип файла:ppt / pptx (powerpoint)
- Всего слайдов:65 слайдов
- Для класса:1,2,3,4,5,6,7,8,9,10,11
- Размер файла:6.26 MB
- Просмотров:69
- Скачиваний:0
- Автор:неизвестен
Слайды и текст к этой презентации:
№2 слайд
![Abstract C is being deployed](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img1.jpg)
Содержание слайда: Abstract
C++11 is being deployed and the shape of C++14 is becoming clear. This talk examines the foundations of C++. What is essential? What sets C++ apart from other languages? How does new and old features support (or distract from) design and programming relying on this essence.
I focus on the abstraction mechanisms (as opposed to the mapping to the machine): Classes and templates. Fundamentally, if you understand vector, you understand C++.
Type safety and resource safety are key design aims for a program. These aims must be met without limiting the range of applications and without imposing significant run-time or space overheads. I address issues of resource management (garbage collection is not an ideal answer and pointers should not be used as resource handles), generic programming (we must make it simpler and safer), compile-time computation (how and when?), and type safety (casts belongs in the lowest-level hardware interface). I will touch upon move semantics, exceptions, concepts, type aliases, and more. My aim is not so much to present novel features and technique, but to explore how C++’s feature set supports a new and more effective design and programming style.
Primary audience
Experienced programmers with weak C++ understanding
Academics/Teachers/Mentors
Architects (?)
№4 слайд
![What did do I want? Type](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img3.jpg)
Содержание слайда: What did/do I want?
Type safety
Encapsulate necessary unsafe operations
Resource safety
It’s not all memory
Performance
For some parts of almost all systems, it’s important
Predictability
For hard and soft real time
Teachability
Complexity of code should be proportional to the complexity of the task
Readability
People and machines (“analyzability”)
№9 слайд
![What does C offer? Not](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img8.jpg)
Содержание слайда: What does C++ offer?
Not perfection
Of course
Not everything for everybody
Of course
A solid fundamental model
Yes, really
30+ years of real-world “refinement”
It works
Performance
A match for anything
The best is buried in “compatibility stuff’’
long-term stability is a feature
№12 слайд
![Classes Construction](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img11.jpg)
Содержание слайда: Classes: Construction/Destruction
From the first week of “C with Classes” (1979)
class X { // user-defined type
public: // interface
X(Something); // constructor from Something
~X(); // destructor
// …
private: // implementation
// …
};
“A constructor establishes the environment for the members to run in; the destructor reverses its actions.”
№13 слайд
![Abstract Classes and](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img12.jpg)
Содержание слайда: Abstract Classes and Inheritance
Insulate the user from the implementation
struct Device { // abstract class
virtual int put(const char*) = 0; // pure virtual function
virtual int get(const char*) = 0;
};
No data members, all data in derived classes
“not brittle”
Manipulate through pointer or reference
Typically allocated on the free store (“dynamic memory”)
Typically requires some form of lifetime management (use resource handles)
Is the root of a hierarchy of derived classes
№14 слайд
![Parameterized Types and](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img13.jpg)
Содержание слайда: Parameterized Types and Classes
Templates
Essential: Support for generic programming
Secondary: Support for compile-time computation
template<typename T>
class vector { /* … */ }; // a generic type
vector<double> constants = {3.14159265359, 2.54, 1, 6.62606957E-34, }; // a use
template<typename C>
void sort (Cont& c) { /* … */ } // a generic function
sort(constants); // a use
№15 слайд
![Not C fundamental No crucial](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img14.jpg)
Содержание слайда: Not C++ (fundamental)
No crucial dependence on a garbage collector
GC is a last and imperfect resort
No guaranteed type safety
Not for all constructs
C compatibility, history, pointers/arrays, unions, casts, …
No virtual machine
For many reasons, we often want to run on the real machine
You can run on a virtual machine (or in a sandbox) if you want to
№18 слайд
![Resource management A](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img17.jpg)
Содержание слайда: Resource management
A resource should be owned by a “handle”
A “handle” should present a well-defined and useful abstraction
E.g. a vector, string, file, thread
Use constructors and a destructor
class Vector { // vector of doubles
Vector(initializer_list<double>); // acquire memory; initialize elements
~Vector(); // destroy elements; release memory
// …
private:
double* elem; // pointer to elements
int sz; // number of elements
};
void fct()
{
Vector v {1, 1.618, 3.14, 2.99e8}; // vector of doubles
// …
}
№19 слайд
![Resource management A handle](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img18.jpg)
Содержание слайда: Resource management
A handle usually is scoped
Handles lifetime (initialization, cleanup), and more
Vector::Vector(initializer_list<double> lst)
:elem {new double[lst.size()]}, sz{lst.size()}; // acquire memory
{
uninitialized_copy(lst.begin(),lst.end(),elem); // initialize elements
}
Vector::~Vector()
{
delete[] elem; // destroy elements; release memory
};
№20 слайд
![Resource management What](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img19.jpg)
Содержание слайда: Resource management
What about errors?
A resource is something you acquire and release
A resource should have an owner
Ultimately “root” a resource in a (scoped) handle
“Resource Acquisition Is Initialization” (RAII)
Acquire during construction
Release in destructor
Throw exception in case of failure
Can be simulated, but not conveniently
Never throw while holding a resource not owned by a handle
In general
Leave established invariants intact when leaving a scope
№21 слайд
![Resource Acquisition is](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img20.jpg)
Содержание слайда: “Resource Acquisition is Initialization” (RAII)
For all resources
Memory (done by std::string, std::vector, std::map, …)
Locks (e.g. std::unique_lock), files (e.g. std::fstream), sockets, threads (e.g. std::thread), …
std::mutex mtx; // a resource
int sh; // shared data
void f()
{
std::lock_guard lck {mtx}; // grab (acquire) the mutex
sh+=1; // manipulate shared data
} // implicitly release the mutex
№22 слайд
![Pointer Misuse Many most?](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img21.jpg)
Содержание слайда: Pointer Misuse
Many (most?) uses of pointers in local scope are not exception safe
void f(int n, int x)
{
Gadget* p = new Gadget{n}; // look I’m a java programmer!
// …
if (x<100) throw std::runtime_error{“Weird!”}; // leak
if (x<200) return; // leak
// …
delete p; // and I want my garbage collector!
}
But, garbage collection would not release non-memory resources anyway
But, why use a “naked” pointer?
№23 слайд
![Resource Handles and Pointers](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img22.jpg)
Содержание слайда: Resource Handles and Pointers
A std::shared_ptr releases its object at when the last shared_ptr to it is destroyed
void f(int n, int x)
{
shared_ptr<Gadget> p {new Gadget{n}}; // manage that pointer!
// …
if (x<100) throw std::runtime_error{“Weird!”}; // no leak
if (x<200) return; // no leak
// …
}
shared_ptr provides a form of garbage collection
But I’m not sharing anything
use a unique_ptr
№25 слайд
![Why do we use pointers? And](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img24.jpg)
Содержание слайда: Why do we use pointers?
And references, iterators, etc.
To represent ownership
Don’t! Instead, use handles
To reference resources
from within a handle
To represent positions
Be careful
To pass large amounts of data (into a function)
E.g. pass by const reference
To return large amount of data (out of a function)
Don’t! Instead use move operations
№26 слайд
![How to get a lot of data](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img25.jpg)
Содержание слайда: How to get a lot of data cheaply out of a function?
Ideas
Return a pointer to a new’d object
Who does the delete?
Return a reference to a new’d object
Who does the delete?
Delete what?
Pass a target object
We are regressing towards assembly code
Return an object
Copies are expensive
Tricks to avoid copying are brittle
Tricks to avoid copying are not general
Return a handle
Simple and cheap
№29 слайд
![No garbage collection needed](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img28.jpg)
Содержание слайда: No garbage collection needed
For general, simple, implicit, and efficient resource management
Apply these techniques in order:
Store data in containers
The semantics of the fundamental abstraction is reflected in the interface
Including lifetime
Manage all resources with resource handles
RAII
Not just memory: all resources
Use “smart pointers”
They are still pointers
Plug in a garbage collector
For “litter collection”
C++11 specifies an interface
Can still leak non-memory resources
№30 слайд
![Range-for, auto, and move As](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img29.jpg)
Содержание слайда: Range-for, auto, and move
As ever, what matters is how features work in combination
template<typename C, typename V>
vector<Value_type<C>*> find_all(C& c, V v) // find all occurrences of v in c
{
vector<Value_type<C>*> res;
for (auto& x : c)
if (x==v)
res.push_back(&x);
return res;
}
string m {"Mary had a little lamb"};
for (const auto p : find_all(m,'a')) // p is a char*
if (*p!='a')
cerr << "string bug!\n";
№31 слайд
![RAII and Move Semantics All](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img30.jpg)
Содержание слайда: RAII and Move Semantics
All the standard-library containers provide it
vector
list, forward_list (singly-linked list), …
map, unordered_map (hash table),…
set, multi_set, …
…
string
So do other standard resources
thread, lock_guard, …
istream, fstream, …
unique_ptr, shared_ptr
…
№33 слайд
![Class hierarchies Protection](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img32.jpg)
Содержание слайда: Class hierarchies
Protection model
No universal base class
an unnecessary implementation-oriented artifact
imposes avoidable space and time overheads.
encourages underspecified (overly general) interfaces
Multiple inheritance
Separately consider interface and implementation
Abstract classes provide the most stable interfaces
Minimal run-time type identification
dynamic_cast<D*>(pb)
typeid(p)
№36 слайд
![Generic Programming Templates](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img35.jpg)
Содержание слайда: Generic Programming: Templates
1980: Use macros to express generic types and functions
1987 (and current) aims:
Extremely general/flexible
“must be able to do much more than I can imagine”
Zero-overhead
vector/Matrix/… to compete with C arrays
Well-specified interfaces
Implying overloading, good error messages, and maybe separate compilation
“two out of three ain’t bad”
But it isn’t really good either
it has kept me concerned/working for 20+ years
№37 слайд
![Templates Compile-time duck](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img36.jpg)
Содержание слайда: Templates
Compile-time duck typing
Leading to template metaprogramming
A massive success in C++98, better in C++11, better still in C++14
STL containers
template<typename T> class vector { /* … */ };
STL algorithms
sort(v.begin(),v.end());
And much more
Better support for compile-time programming
C++11: constexpr (improved in C++14)
№38 слайд
![Algorithms Messy code is a](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img37.jpg)
Содержание слайда: Algorithms
Messy code is a major source of errors and inefficiencies
We must use more explicit, well-designed, and tested algorithms
The C++ standard-library algorithms are expressed in terms of half-open sequences [first:last)
For generality and efficiency
void f(vector<int>& v, list<string>& lst)
{
sort(v.begin(),v.end()); // sort the vector using <
auto p = find(lst.begin(),lst.end(),"Aarhus"); // find “Aarhus” in the list
// …
}
We parameterize over element type and container type
№39 слайд
![Algorithms Simple, efficient,](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img38.jpg)
Содержание слайда: Algorithms
Simple, efficient, and general implementation
For any forward iterator
For any (matching) value type
template<typename Iter, typename Value>
Iter find(Iter first, Iter last, Value val) // find first p in [first:last) so that *p==val
{
while (first!=last && *first!=val)
++first;
return first;
}
№41 слайд
![Algorithms and Function](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img40.jpg)
Содержание слайда: Algorithms and Function Objects
The implementation is still trivial
template<typename Iter, typename Predicate>
Iter find_if(Iter first, Iter last, Predicate pred) // find first p in [first:last) so that pred(*p)
{
while (first!=last && !pred(*first))
++first;
return first;
}
№42 слайд
![Function Objects and Lambdas](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img41.jpg)
Содержание слайда: Function Objects and Lambdas
General function object
Can carry state
Easily inlined (i.e., close to optimally efficient)
struct Less_than {
String s;
Less_than(const string& ss) :s{ss} {} // store the value to compare against
bool operator()(const string& v) const { return v<s; } // the comparison
};
Lambda notation
We can let the compiler write the function object for us
auto p = std::find_if(vs.begin(),vs.end(),
[](const string& v) { return v<"Griffin"; } );
№43 слайд
![Container algorithms The C](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img42.jpg)
Содержание слайда: Container algorithms
The C++ standard-library algorithms are expressed in terms of half-open sequences [first:last)
For generality and efficiency
If you find that verbose, define container algorithms
namespace Extended_STL {
// …
template<typename C, typename Predicate>
Iterator<C> find_if(C& c, Predicate pred)
{
return std::find_if(c.begin(),c.end(),pred);
}
// …
}
auto p = find_if(v, [](int x) { return x%2; } ); // assuming v is a vector<int>
№44 слайд
![Duck Typing is Insufficient](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img43.jpg)
Содержание слайда: Duck Typing is Insufficient
There are no proper interfaces
Leaves error detection far too late
Compile- and link-time in C++
Encourages a focus on implementation details
Entangles users with implementation
Leads to over-general interfaces and data structures
As programmers rely on exposed implementation “details”
Does not integrate well with other parts of the language
Teaching and maintenance problems
We must think of generic code in ways similar to other code
Relying on well-specified interfaces (like OO, etc.)
№45 слайд
![Generic Programming is just](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img44.jpg)
Содержание слайда: Generic Programming is just Programming
Traditional code
double sqrt(double d); // C++84: accept any d that is a double
double d = 7;
double d2 = sqrt(d); // fine: d is a double
double d3 = sqrt(&d); // error: &d is not a double
Generic code
void sort(Container& c); // C++14: accept any c that is a Container
vector<string> vs { "Hello", "new", "World" };
sort(vs); // fine: vs is a Container
sort(&vs); // error: &vs is not a Container
№46 слайд
![C Constraints aka Concepts](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img45.jpg)
Содержание слайда: C++14: Constraints aka “Concepts lite”
How do we specify requirements on template arguments?
state intent
Explicitly states requirements on argument types
provide point-of-use checking
No checking of template definitions
use constexpr functions
Voted as C++14 Technical Report
Design by B. Stroustrup, G. Dos Reis, and A. Sutton
Implemented by Andrew Sutton in GCC
There are no C++0x concept complexities
No concept maps
No new syntax for defining concepts
No new scope and lookup issues
№47 слайд
![What is a Concept? Concepts](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img46.jpg)
Содержание слайда: What is a Concept?
Concepts are fundamental
They represent fundamental concepts of an application area
Concepts are come in “clusters” describing an application area
A concept has semantics (meaning)
Not just syntax
“Subtractable” is not a concept
We have always had concepts
C++: Integral, arithmetic
STL: forward iterator, predicate
Informally: Container, Sequence
Algebra: Group, Ring, …
№48 слайд
![What is a Concept? Don t](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img47.jpg)
Содержание слайда: What is a Concept?
Don’t expect to find a new fundamental concept every year
A concept is not the minimal requirements for an implementation
An implementation does not define the requirements
Requirements should be stable
Concepts support interoperability
There are relatively few concepts
We can remember a concept
№49 слайд
![C Concepts Constraints A](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img48.jpg)
Содержание слайда: C++14 Concepts (Constraints)
A concept is a predicate on one or more arguments
E.g. Sequence<T>() // is T a Sequence?
Template declaration
template <typename S, typename T>
requires Sequence<S>()
&& Equality_comparable<Value_type<S>, T>()
Iterator_of<S> find(S& seq, const T& value);
Template use
void use(vector<string>& vs)
{
auto p = find(vs,"Jabberwocky");
// …
}
№50 слайд
![C Concepts Error handling](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img49.jpg)
Содержание слайда: C++14 Concepts: Error handling
Error handling is simple (and fast)
template<Sortable Cont>
void sort(Cont& container);
vector<double> vec {1.2, 4.5, 0.5, -1.2};
list<int> lst {1, 3, 5, 4, 6, 8,2};
sort(vec); // OK: a vector is Sortable
sort(lst); // Error at (this) point of use: Sortable requires random access
Actual error message
error: ‘list<int>’ does not satisfy the constraint ‘Sortable’
№51 слайд
![C Concepts Shorthand Notation](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img50.jpg)
Содержание слайда: C++14 Concepts: “Shorthand Notation”
Shorthand notation
template <Sequence S, Equality_comparable<Value_type<S>> T>
Iterator_of<C> find(S& seq, const T& value);
We can handle essentially all of the Palo Alto TR
(STL algorithms) and more
Except for the axiom parts
We see no problems checking template definitions in isolation
But proposing that would be premature (needs work, experience)
We don’t need explicit requires much (the shorthand is usually fine)
№52 слайд
![C Concepts Overloading](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img51.jpg)
Содержание слайда: C++14 Concepts: Overloading
Overloading is easy
template <Sequence S, Equality_comparable<Value_type<S>> T>
Iterator_of<S> find(S& seq, const T& value);
template<Associative_container C>
Iterator_type<C> find(C& assoc, const Key_type<C>& key);
vector<int> v { /* ... */ };
multiset<int> s { /* … */ };
auto vi = find(v, 42); // calls 1st overload:
// a vector is a Sequence
auto si = find(s, 12-12-12); // calls 2nd overload:
// a multiset is an Associative_container
№53 слайд
![C Concepts Overloading](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img52.jpg)
Содержание слайда: C++14 Concepts: Overloading
Overloading based on predicates
specialization based on subset
Far easier than writing lots of tests
template<Input_iterator Iter>
void advance(Iter& p, Difference_type<Iter> n) { while (n--) ++p; }
template<Bidirectional_iterator Iter>
void advance(Iter& i, Difference_type<Iter> n)
{ if (n > 0) while (n--) ++p; if (n < 0) while (n++) --ip}
template<Random_access_iterator Iter>
void advance(Iter& p, Difference_type<Iter> n) { p += n; }
We don’t say
Input_iterator < Bidirectional_iterator < Random_access_iterator
we compute it
№54 слайд
![C Concepts Definition How do](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img53.jpg)
Содержание слайда: C++14 Concepts: Definition
How do you write constraints?
Any bool expression
Including type traits and constexpr function
a requires(expr) expression
requires() is a compile time intrinsic function
true if expr is a valid expression
To recognize a concept syntactically, we can declare it concept
Rather than just constexpr
№55 слайд
![C Concepts Terse Notation We](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img54.jpg)
Содержание слайда: C++14 Concepts: “Terse Notation”
We can use a concept name as the name of a type than satisfy the concept
void sort(Container& c); // terse notation
means
template<Container __Cont> // shorthand notation
void sort(__Cont& c);
means
template<typename __Cont> // explicit use of predicate
requires Container<__Cont>()
void sort(__Cont)& c;
Accepts any type that is a Container
vector<string> vs;
sort(vs);
№56 слайд
![C Concepts Terse Notation We](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img55.jpg)
Содержание слайда: C++14 Concepts: “Terse Notation”
We have reached the conventional notation
with the conventional meaning
Traditional code
double sqrt(double d); // C++84: accept any d that is a double
double d = 7;
double d2 = sqrt(d); // fine: d is a double
double d3 = sqrt(&d); // error: &d is not a double
Generic code
void sort(Container& c); // C++14: accept any c that is a Container
vector<string> vs { "Hello", "new", "World" };
sort(vs); // fine: vs is a Container
sort(&vs); // error: &vs is not a Container
№57 слайд
![C Concepts Terse Notation](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img56.jpg)
Содержание слайда: C++14 Concepts: “Terse Notation”
Consider std::merge
Explicit use of predicates:
template<typename For,
typename For2,
typename Out>
requires Forward_iterator<For>()
&& Forward_iterator<For2>()
&& Output_iterator<Out>()
&& Assignable<Value_type<For>,Value_type<Out>>()
&& Assignable<Value_type<For2,Value_type<Out>>()
&& Comparable<Value_type<For>,Value_type<For2>>()
void merge(For p, For q, For2 p2, For2 q2, Out p);
Headache inducing, and accumulate() is worse
№59 слайд
![C Concepts Terse Notation](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img58.jpg)
Содержание слайда: C++14 Concepts: “Terse Notation”
Better still, use the “terse notation”:
Mergeable{For,For2,Out} // Mergeable is a concept requiring three types
void merge(For p, For q, For2 p2, For2 q2, Out p);
The
concept-name { identifier-list }
notation introduces constrained names
Make simple things simple!
№60 слайд
![C Concepts Terse Notation Now](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img59.jpg)
Содержание слайда: C++14 Concepts: “Terse Notation”
Now we just need to define Mergeable:
template<typename For, typename For2, typename Out>
concept bool Mergeable()
{
return Forward_iterator<For>()
&& Forward_iterator<For2>()
&& Output_iterator<Out>()
&& Assignable<Value_type<For>,Value_type<Out>>()
&& Assignable<Value_type<For2,Value_type<Out>>()
&& Comparable<Value_type<For>,Value_type<For2>>();
}
It’s just a predicate
№62 слайд
![C Challenges Obviously, C is](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img61.jpg)
Содержание слайда: C++ Challenges
Obviously, C++ is not perfect
How can we make programmers prefer modern styles over low-level code
which is far more error-prone and harder to maintain, yet no more efficient?
How can we make C++ a better language given the Draconian constraints of C and C++ compatibility?
How can we improve and complete the techniques and models (incompletely and imperfectly) embodied in C++?
Solutions that eliminate major C++ strengths are not acceptable
Compatibility
link, source code
Performance
uncompromising
Portability
Range of application areas
Preferably increasing the range
№63 слайд
![Long-term C Challenges Close](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img62.jpg)
Содержание слайда: Long-term C++ Challenges
Close more type loopholes
in particular, find a way to prevent misuses of delete without spoiling RAII
Simplify concurrent programming
in particular, provide some higher-level concurrency models as libraries
Simplify generic programming
in particular, introduce simple and effective concepts
Simplify programming using class hierarchies
in particular, eliminate use of the visitor pattern
Better support for combinations of object-oriented and generic programming
Make exceptions usable for hard-real-time projects
that will most likely be a tool rather than a language change
Find a good way of using multiple address spaces
as needed for distributed computing
would probably involve defining a more general module mechanism that would also address dynamic linking, and more.
Provide many more domain-specific libraries
Develop a more precise and formal specification of C++
№64 слайд
![Paradigms Much of the](/documents_6/a498dff23ea3e00922c7db17c02d0f18/img63.jpg)
Содержание слайда: “Paradigms”
Much of the distinction between object-oriented programming, generic programming, and “conventional programming” is an illusion
based on a focus on language features
incomplete support for a synthesis of techniques
The distinction does harm
by limiting programmers, forcing workarounds
void draw_all(Container& c) // is this OOP, GP, or conventional?
requires Same_type<Value_type<Container>,Shape*>
{
for_each(c, [](Shape* p) { p->draw(); } );
}
Скачать все slide презентации The Essence of C with examples in C84, C98, C11, and C14 одним архивом:
Похожие презентации
-
Machine Learning: the main goal, some examples and facts
-
5B070500 «Mathematical and Computer Modeling» Образовательные программы
-
Mathematical functions, characters, and strings. Introduction to Java Programming
-
RhinoScript 101 Creativity "or how to do interesting things that are not easy to do with the mouse"
-
AmigaOS is a family of proprietary native operating systems of the Amiga and AmigaOne personal
-
HTML. The standard markup language for creating Web pages
-
Prolog. A general-purpose logic programming language associated with artificial intelligence and computational linguistics
-
OOP with C. Introduction C. Data Types. Variables, expressions, statements. C decision and iteration constructs
-
Introducing the C Class Types. Defining classes, objects and methods
-
C Classes How to Create and Use Them (Constructor, Destructor)