Explore
For Enterprise
Join for Free
Log In

artes y humanidades
Negocios
Ciencias de la Computación
Ciencia de Datos
Tecnología de información
salud
Matemáticas y Lógica
Desarrollo Personal
Ciencias Físicas e Ingeniería
Ciencias sociales
Aprendizaje de un idioma
Grados
Certificados

Explorar todo lo que Coursera tiene para ofrecer

Explorar
Buscar
For Enterprise
Inicia Sesión
Únete de forma gratuita

2.7 Enum & Operator Overloading

Loading...

C++ For C Programmers, Part A

Universidad de California en Santa Cruz

4.4 (647 calificaciones) | 95K estudiantes inscritos

This course is for experienced C programmers who want to program in C++. The examples and exercises require a basic understanding of algorithms and object-oriented software.

Destrezas que aprenderás

Graph Theory, C++11, C++, Graph Algorithms

Revisiones

4.4 (647 calificaciones)

5 stars
420 ratings
4 stars
147 ratings
3 stars
34 ratings
2 stars
20 ratings
1 star
26 ratings

AK

Jul 04, 2017

I like Prof. Ira a lot and wish to see more courses from him! I wish I was his student at SC. Best Regards to him and the Coursera team for the great work.

PK

Jul 18, 2018

I really loved this course. It is really helpul for my programming aspect. I have managed to develop my logical abilty and this course really helped me.

De la lección

Module 2

Review of Dijkstra's shortest path algorithm. C++ Functions and Generics. C++ classes and OO. Point as an example.

2.1 C++ Generics and Functions14:13

2.2 Multiple Template Arguments8:48

2.3 Graph Theory & Algorithms9:33

2.4 Graph as a Data Structure11:10

2.5 Dijkstra Shortest Path16:42

2.6 C++ Creating Types5:22

2.7 Enum & Operator Overloading4:04

2.8 Example: typedef days18:39

2.9 Natural Way to Build Widgets6:47

2.10 C++ Point26:58

Impartido por:

Ira Pohl
Professor

Transcripción

Object oriented programming lets us program naturally in new domains,

domains that not necessarily have types in the native language that fit the domains.

So for example,

we might want to write programs that involve manipulation of colors.

Imagine having a windowing system and

inside your windowing system you have different menu options.

And possibly within the window options,

you're using color to add different levels of expressivity.

So you might want a color type.

This is a simple form of type extensibility,

typically colors could be defined as a small, discrete set of items.

So here we see,

an enumerated type which is one form of type extensibility in the C++ language.

That has a color RED, a color WHITE, and a color GREEN.

Now, with these colors, this is basically a form of simple integer type,

and the reason we use capital RED is that's just,

that's an identifier, that's an enumerator.

So enum id.

And capitalization.

Are a convention.

They just highlight that, we're expressing a form of integer constant.

And red, when no value is specified, will be automatically assigned zero.

That's in the old grand tradition of the C community.

Everything starts at zero.

WHITE will be 1, and GREEN will be 2.

And that's what we'll do normally.

We also will have the ability to override these values by being explicit.

We could say, white is 3.

And that would mean, that red starts zero, white starts at three, and

then the sequence continues from three to four.

Now, why should we use enum?

Some of you have experienced enum.

Enum was added even to the C language,

and in many other programming languages, there are enumerated types.

It's a multiple choice question, just take a second, Can you use a named

integer instead of an enumerated type to get that kind of constant?

Can you use a #define much like in the pre processor keeping C

old style, for these enumerator constants like red and white.

Or is it best to have a small related set of constants?

So which reason exists for using enum?

It is quite true that, you can just use cost

declaration for example, if you wanted true and

false as two related constants, we can say,

constant TRUE is 1 and constant,

FALSE is 0 then we would have that.

We can also use this in old C style, but again, there's safety issues.

But enumerated types are even better than either of these others,

where there is a grouping of related constants.

Where you wanna think about as type extensibility and

not just arbitrary name integer constants.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2019 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play

Coursera
Acerca de
Liderazgo
Empleo
Catálogo
Certificados
Certificados MasterTrack™
Grados
For Enterprise
For Government

Comunidad
Learners
Partners
Developers
Beta Testers
Translators

Conectar
Blog
Facebook
LinkedIn
Twitter
Instagram
Youtube
Blog de Tecnología

Más
Términos
Privacidad
Ayuda
Accesibilidad
Prensa
Contacto
Directorio
Afiliados