Estructura de un programa+.pdfEstructura de un programa Probablemente la mejor manera de comenzar a aprender un lenguaje de programación está escribiendo un programa. Por lo tanto,

ASIGNATURA: C++ BÁSICO.

TÉCNICO EN SISTEMAS COMPUTACIONALES.

LIC. EDGAR DE LA CRUZ GARCÍA.

Estructura de un programa

Probablemente la mejor manera de comenzar a aprender un lenguaje de programación está escribiendo un programa. Por lo tanto, aquí está nuestro primer programa:

// mi primer programa en C++

# incluya el < iostream >

el usar

namespace

std;

interno

cañería () { cout < < "hola

mundo!"

vuelta

0; }

¡Hola Mundo!

El primer panel demuestra el código de fuente para nuestro primer programa. Segundo demuestra el resultado del programa compilado y ejecutado una vez. La manera de corregir y de compilar un programa depende del recopilador que usted está utilizando. Dependiendo de si tiene un interfaz del desarrollo o no y en su versión. Consulte la sección de los recopiladores y el manual o ayude a incluido con su recopilador si usted tiene dudas en cómo compilar un programa de la consola de C++.

El programa anterior es el programa típico que los aprendices del programador escriben para la primera vez, y su resultado es la impresión en la pantalla "hola del mundo!" oración. Es uno de los programas más simples que se pueden escribir en C++, pero contiene ya los componentes fundamentales que cada programa de C++ tiene. Vamos a mirar la línea por la línea el código que acabamos de escribir:

// mi primer programa en C++

Esto es una línea de comentario. Todas las líneas que comienzan con dos muestras

de la raya vertical (// ) se consideran los comentarios y no tienen ningún efecto en

el comportamiento del programa. El programador puede utilizarlas para incluir las explicaciones o las observaciones cortas dentro del código de fuente sí mismo. En este caso, la línea es una breve descripción de cuál es nuestro programa.


Las líneas que comienzan con una muestra de la libra ( # ) son directorios para el

preprocesador. Son no líneas de código regulares con expresiones sino las

indicaciones para el preprocesador del recopilador. En este caso el directivos #

incluyen el < iostream > dicen el preprocesador incluir el archivo del

estándar del iostream. Este archivo específico (iostream) incluye los declaraciones de la biblioteca estándar básica de la entrada-salida en C++, y él es incluido porque su funcionalidad va a ser utilizada más adelante en el programa.

usar namespace std;

Todos los elementos de la biblioteca estándar de C++ se declaran dentro de qué se llama un namespace, el namespace con el nombre std . Para tener acceso tan a su funcionalidad declaramos con esta expresión que utilizaremos estas entidades. Esta línea es muy frecuente en los programas de C++ que utilizan la biblioteca estándar, y en hecho será incluido en la mayoría de los códigos de fuente incluidos en estas clases particulares.

cañería interna ()

Esta línea corresponde al principio de la definición de la función principal. La función principal es el punto cerca donde todos los programas de C++ comienzan su ejecución, independientemente de su localización dentro del código de fuente. No




importa si haya otras funciones con otros nombres definidos antes después de ella - las instrucciones contenidas dentro de la definición de esta función serán siempre primeras que se ejecutarán en cualquier programa de C++. Por esa misma razón, es esencial que todos los programas de C++ tienen una función principal.

La cañería de la palabra es seguida en el código por un par de paréntesis ( () ).

Eso es porque es un declaración de la función: En C++, qué distingue un declaración de la función de otros tipos de expresiones están estos paréntesis que siguen su nombre. Opcionalmente, estos paréntesis pueden incluir una lista de parámetros dentro de ellos.

Derecho después de que estos paréntesis nosotros puedan encontrar el cuerpo de la función principal incluida en apoyos ( { } ). Qué se contiene dentro de estos

apoyos es lo que hace la función cuando se ejecuta.

cout < < "hola mundo";

Esta línea es una declaración de C++. Una declaración es una expresión simple o compuesta que puede producir realmente un cierto efecto. En hecho, esta declaración realiza la única acción que genera un efecto visible en nuestro primer programa.

el cout representa la corriente estándar de la salida en C++, y el significado de la

declaración entera es insertar una secuencia de caracteres (en este caso hola la

secuencia del mundo de caracteres) en la corriente estándar de la salida (que es

generalmente la pantalla).

cout ser declarar en iostream estándar archivo dentro std namespace, así que

que ser porqué nosotros necesitar para incluir ese específico archivo y para declarar que nosotros ser ir para utilizar este específico namespace temprano en nuestro código.

Note que la declaración termina con un carácter del punto y coma (; ). Este carácter

ser utilizar para marcar extremo declaración y en hecho él deber ser incluido en extremo todo expresión declaración en todo C++ programa (uno más común sintaxis error ser de hecho para olvidar para incluir alguno punto y después uno declaración).

vuelta 0;

La declaración de vuelta causa la función principal a la vuelta del final se puede seguir por un código de retorno (en nuestro ejemplo es seguido por el código de

retorno 0 ). Un código de retorno de 0 para la función principal se interpreta

generalmente como el programa trabajó según lo esperado sin ningunos errores durante su ejecución. Ésta es la manera más generalmente de terminar un programa de C++.

Usted pudo haber notado que no todas las líneas de este programa realizan acciones cuando se ejecuta el código. Había líneas que contenían solamente los comentarios (ésos que comienzan por // ). Había líneas con los directorios para el preprocesador del recopilador

(ésas que comienzan por # ). Entonces había las líneas que comenzaron el declaración de

una función (en este caso, la función principal) y, finalmente alinea con las declaraciones (como la inserción en cout ), que todas fueron incluidas dentro del bloque delimitado por

los apoyos ( { } ) de la función principal.

El programa se ha estructurado en diversas líneas para ser más legible, pero en C++, no tenemos reglas terminantes en cómo separar instrucciones en diversas líneas. Por ejemplo, en vez de

interno

cañería () { cout < < "hola mundo"




vuelta

0; }

Habríamos podido escribir:

interno

cañería () { cout < < "hola mundo"

vuelta

0; }

Todos en apenas una línea y ésta habrían tenido exactamente el mismo significado que el código anterior.

En C++, la separación entre las declaraciones se especifica con un punto y coma del

conclusión (; ) en el final de cada, así que la separación en diversas líneas de código no

importa en todo el para este propósito. Podemos escribir muchas declaraciones por línea o escribir una sola declaración que tome muchas líneas de código. La división del código en diversas líneas sirve solamente para hacer la más legible y el diagrama esquemático para los seres humanos que pueden leerlo.

Agreguemos una instrucción adicional a nuestro primer programa:

// mi segundo programa en C++


el usar

namespace

std;

interno

¡cañería () { cout < < "hola

mundo! "

cout < < "soy un programa de

C++"

vuelta

0; }

¡Hola Mundo! Soy un programa de

C++

En este caso, realizamos dos inserciones en cout en dos diversas declaraciones. De nuevo, la separación en diversas líneas del código acaba de hacerse da mayor legibilidad al programa, puesto que la cañería habría podido ser perfectamente válida definió esta manera:

interno

¡cañería () { cout < < "hola mundo! "

cout < < "soy un programa de C++"

vuelta

0; }

Estábamos también libres dividir el código en más líneas si lo considerábamos más conveniente:

interno

cañería () { cout < <

"hola mundo!"





vuelta

0; }

Y el resultado habría estado otra vez exactamente igual que en los ejemplos anteriores.

Los directorios del preprocesador (ésos por los cuales comience # ) están fuera de esta regla

general puesto que no son declaraciones. Son líneas leídas y desechadas por el preprocesador y no producen ningún código por sí mismos. Los directorios del preprocesador

se deben especificar en su propia línea y no tienen que terminar con un punto y coma (; ).

Comentarios

Los comentarios son parte del código de fuente desatendido por el recopilador. No hacen simplemente nada. Su propósito es permitir solamente que el programador inserte las notas o las descripciones encajadas dentro del código de fuente.

Ayudas de C++ dos maneras de insertar comentarios:

// comentario de la línea

/* */

del comentario

del bloque

El primer de ellos, conocido como comentario de la línea, desecha todo de donde el par de

las muestras de la raya vertical (// ) se encuentra hasta el extremo de esa misma línea.

Segundo, sabido como el comentario del bloque, desecha todo entre /* los caracteres y el

primer aspecto del */ los caracteres, con la posibilidad de incluir más de una línea.

Vamos a agregar comentarios a nuestro segundo programa:

/* mi segundo programa en C++ con

más comenta */


el usar

namespace

std;

interno

¡cañería () { cout < < "hola

mundo! "

¡//mundo de las impresiones

hola!


// las impresiones soy un

programa de C++

vuelta

0; }

¡Hola Mundo! Soy un programa de

C++

Si usted incluye comentarios dentro del código de fuente de sus programas sin usar//, /* de

las combinaciones de los caracteres del comentario o */, el recopilador los tomará




como si fueran expresiones de C++, muy probablemente causando un o vario mensajes de error cuando usted lo compila.

VARIABLES. TIPOS DE DATOS.

La utilidad "hola de los programas del mundo" demostrados en la sección anterior es absolutamente cuestionable. Tuvimos que escribir varias líneas del código, las compilamos, y después ejecutamos el programa que resultaba apenas para obtener una oración simple escrita en la pantalla como resultado. Habría sido ciertamente mucho más rápido mecanografiar la oración de la salida de nosotros mismos. Sin embargo, la programación no se limita solamente a imprimir los textos simples en la pantalla. Para ir un poco más lejos en y llegar a ser capaz de escribir los programas que realizan las tareas útiles que realmente excepto nosotros el trabajo nosotros necesita para introducir el concepto de la variable.

Pensemos que pido usted conserve el número 5 en su memoria mental, y entonces pido que usted memorice también el número 2 en el mismo tiempo. Usted acaba de almacenar dos diversos valores en su memoria. Ahora, si pido que usted agregue 1 al primer número I dicho, usted debe conservar los números 6 (que es 5+1) y 2 en su memoria. Valores que podríamos ahora por ejemplo restar y obtener 4 como resultado.

El proceso entero que usted acaba de hacer con su memoria mental es un simile de una qué computadora puede hacer con dos variables. El mismo proceso se puede expresar en C++ con el sistema de instrucción siguiente:

a = 5; b = 2; a = a + 1; resultado = a - b;

Obviamente, esto es un ejemplo muy simple puesto que hemos utilizado solamente dos valores pequeños del número entero, pero considera que su computadora puede almacenar millones de números como éstos en el mismo tiempo y conducir operaciones matemáticas sofisticadas con ellas.

Por lo tanto, podemos definir una variable como una porción de la memoria para almacenar un valor resuelto.

Cada variable necesita un identificador que la distinga de las otras, por ejemplo, en el código anterior los identificadores variables eran a, b y resultado, pero habríamos podido llamar las variables cualquier nombre que deseáramos inventar, mientras eran identificadores válidos.

Identificadores

Un identificador válido es una secuencia de unas o más letras, dígitos o caracteres de la raya

( _ ). Ni los espacios ni los signos o los símbolos de puntuación pueden ser parte de un

identificador. Solamente las letras, los dígitos y los caracteres de la raya son válidos. Además, los identificadores variables tienen que comenzar siempre con una letra. Pueden también para comenzar con un carácter de la raya ( _), pero éste es generalmente

reservado las palabras claves específicas del recopilador o los identificadores externos. En ningún caso pueden comenzar con un dígito.

Otra regla que usted tiene que considerar al inventar sus propios identificadores es que no pueden emparejar ninguna palabra clave del puesto que la lengua de C++ o el específico de su recopilador unos podrían ser confundidos con éstos. Las palabras claves reservadas estándares son:

el asm, automóvil, bool, rotura, caso, retén, carbón, clase, const,

const_cast, continúa, omite, suprime, , doble, dynamic_cast, otro,




enum, explícito, exportación, extern, falsa, flotador, para, el amigo,

goto, si, en línea, interno, largo, mutable, namespace, nuevo,

operador, privado, protegido, público, registro, reinterpret_cast,

vuelta, cortocircuito, firmado, sizeof, parásitos atmosféricos,

static_cast, struct, interruptor, plantilla, ésta, tiro, verdad,

intento, typedef, typeid, typename, la unión, sin firmar, con,

virtual, vacío, volátil, wchar_t, mientras que

Además, las representaciones alternativas para algunos operadores no se pueden utilizar como identificadores puesto que son palabras reservadas bajo algunas circunstancias:

y, and_eq, bitand, bitor, compl, no, not_eq, o, or_eq, xor, xor_eq

Su recopilador puede también incluir algunas palabras claves reservadas específicas adicionales. Muy importante: La lengua de C++ es una lengua sensible del "caso". Eso significa que un identificador escrito en mayúsculas no es equivalente otro con el mismo conocido sino escrito

en letras pequeñas. Así, por ejemplo, la variable del RESULTADO no es igual que el

resultado variable o la variable del resultado. Éstos son tres diversos identificadores

variables.

Tipos de datos fundamentales

Cuando programar, nosotros almacenar variable en nuestro computadora memoria, pero computadora tener que saber lo que nosotros desear para almacenar en, puesto que él ser no ir para ocupar mismo cantidad memoria para almacenar uno simple número que para almacenar uno solo letra o uno grande número, y ser no ir para ser interpretar mismo manera.

La memoria en nuestras computadoras se organiza en octetos. Un octeto es la cantidad mínima de memoria que podemos manejar en C++. Un octeto puede almacenar una cantidad relativamente pequeña de datos: un solo carácter o un número entero pequeño (generalmente un número entero entre 0 y 255). Además, la computadora puede manipular tipos de datos más complejos que vengan de agrupar varios octetos, tales como números largos o números del no-nu'mero entero.

Usted tiene después una lista de los datos fundamentales existentes mecanografía adentro C++, así como la gama de los valores que se pueden representar con cada de ellos: Tipos de datos fundamentales:

Nombre Descripción Tamaño

* Gama *

carbón Carácter o número entero pequeño. 1byte firmado: -128 a 127 sin firmar: 0 a 255

interno Número entero. 1woo

firmado: -2147483648 a 2147483647 sin firmar: 0 a 4294967295

interno corto

cortocircuito Número entero Corto. 2bytes


interno largo

de largo Número entero largo. 4bytes


bool Valor boleano. Puede tomar uno de dos valores: verdad o falso.

1byte verdad o falso

flotador Número de la coma flotante. 4bytes 3.ê +/- 38 (7 dígitos)




doble Número de la coma flotante de la precisión doble.

8bytes 1.7e +/- 308 (15 dígitos)

doble largo Número largo de la coma flotante de la precisión doble.

8bytes 1.7e +/- 308 (15 dígitos)

wchar_t Carácter ancho. 2bytes 1 carácter ancho

* Los valores de las columnas tamaño y gama dependen de la arquitectura del sistema donde se compila y se ejecuta el programa. Los valores incluidos aquí son los más comunes encontrados en los sistemas 32bit.

el cortocircuito y es de largo equivalente para todos los propósitos a interno

interno y largo corto , respectivelly.

Declaración de variables

Para utilizar una variable en C++, debemos primero declararlo que especifican qué tipo de datos quisiéramos que fuera. El sintaxis para declarar una nueva variable es escribir el specifier del tipo de datos deseado (como interno, bool, el flotador...) seguido por un identificador variable válido. Por ejemplo:

interno

a;

flotador

mynumber;

Éstos son dos declaraciones válidos de variables. Primer declara una variable del tipo

interna con el identificador a . Segundo declara una variable del flotador del tipo con

el mynumber del identificador . Una vez que estén declaradas, las variables a y el

mynumber se puedan utilizar dentro del resto de su alcance en el programa.

Si usted va a declarar más que uno variable del mismo tipo, usted puede declarar todos en una sola declaración separando sus identificadores con comas. Por ejemplo:

interno

a, b, c;

Esto declara tres variables ( a , b y c), todos de tipo interno, y tiene exactamente el mismo

significado que:

interno

a;

interno

b;

interno

c;

Los tipos de datos del número entero socarran , corto , de largo e interno puede

estar firmado o sin firmar dependiendo de la gama de los números necesitados para ser representado. Los tipos firmados pueden representar valores positivos y negativos, mientras que los tipos sin firmar pueden representar solamente valores positivos (y cero). Esto puede

ser especificada usando el specifier firmado o el specifier sin firmar antes del nombre

del tipo. Por ejemplo:

sin firmar

cortocircuito

interno

NumberOfSisters;




firmado

interno

MyAccountBalance;

Por el defecto, si no especificamos o firmado o sin firmar la mayoría de los ajustes del

recopilador asumen el tipo que se firmará, por lo tanto en vez del segundo declaración arriba habríamos podido escribir:

interno

MyAccountBalance;

con exactamente el mismo significado (con o sin la palabra clave firmada )

Una excepción a esta regla general es el tipo del carbón, que existe por sí mismo y se

considera un diverso tipo de datos fundamental del carbón firmado y del carbón

sin firmar , pensamiento para almacenar caracteres. Usted debe utilizar o firmado o

sin firmar si usted se prepone almacenar los valores numéricos en un carbón -

variable clasificada.

el cortocircuito y se puede utilizar de largo solamente como specifiers del tipo. En

este caso, refieren a sus tipos fundamentales del número entero respectivo: el

cortocircuito es equivalente a interno corto y es de largo equivalente a interno

largo . Los dos declaraciones variables siguientes son equivalentes:

cortocircuito

Año;

cortocircuito

interno

Año;

Finalmente, firmado y sin firmar se puede también utilizar como specifiers

independientes del tipo, significar igual que interno interno y sin firmar firmada

respectivamente. Los dos declaraciones siguientes son equivalentes:

sin firmar

NextYear;

sin firmar

interno

NextYear;

Para ver qué declaraciones variables parecen en la acción dentro de un programa, vamos a ver el código de C++ del ejemplo sobre su memoria mental propuesta al principio de esta sección:

// que funciona con variables


el usar

namespace

std;

interno

cañería () {

// que declara variables:

4




interno

a, b;

interno

resultado;

// proceso:

a = 5; b = 2; a = a + 1;

resultado = a - b;

// impresión fuera del resultado:

cout < < resultado;

// termine el programa:

vuelva

0; }

No se preocupe si el algo más que los declaraciones variables ellos mismos mira un pedacito extraño a usted. Usted verá el resto detalladamente en secciones que vienen.

Alcance de variables

Todo variable que nosotros preponer para utilizar en uno programa deber tener ser declarar con su tipo specifier en uno temprano punto en código, como nosotros hacer en anterior código en principio cuerpo función cañería cuando nosotros declarar que a , b , y

resultado ser tipo interno .

Una variable puede estar de alcance global o local. Una variable global es una variable declarada en el cuerpo principal del código de fuente, fuera de todas las funciones, mientras que una variable local es una declarada dentro del cuerpo de una función o de un bloque.

Las variables globales se pueden referir dondequiera adentro del código, funciones interiores uniformes, siempre que esté después de su declaración.

El alcance de variables locales se limita al bloque incluido en apoyos ({ }) donde se declaran.

Por ejemplo, si se declaran al principio del cuerpo de una función (como en la cañería de la




función ) su alcance está entre su punto del declaración y el final de esa función. En el

ejemplo arriba, esto significa que si otra función existió además de la cañería , las

variables locales declaradas en cañería no se podrían alcanzar de la otra función y

viceversa.

CONSTANTES

Las constantes son expresiones con un valor fijo.

Literales

Los literales se utilizan para expresar valores particulares dentro del código de fuente de un programa. Hemos utilizado ya éstos damos previamente valores concretos a las variables o a los mensajes expresos quisiéramos que nuestros programas imprimieran hacia fuera, por ejemplo, cuando escribimos:

a = 5;

los 5 en este pedazo del código eran una constante literal.

Las constantes literales se pueden dividir en números del número entero, números floating-Point, caracteres, secuencias y valores boleanos.

Números Del Número entero

1776

707

-273

Son las constantes numéricas que identifican valores del decimal del número entero. Note

eso para expresar una constante numérica que no tenemos que escribir cotizaciones ( ") ni

ningún carácter especial. No hay duda que es una constante: siempre que escribamos 1776

en un programa, referiremos al valor 1776.

Además de los números decimales (los que todos nosotros se utilizan para utilizar cada día) C++ permite el uso como constantes literales de los números octales (base 8) y números hexadecimales (base 16). Si deseamos expresar un número octal tenemos que precederlo

con un 0 (el carácter cero). Y para expresar un número hexadecimal tenemos que

precederlo con los caracteres 0x (cero, x). Por ejemplo, las constantes literales siguientes

son todas equivalentes el uno al otro:

75 // decimal

0113 // octal

0x4b // hexadecimal

Todos los éstos representan el mismo número: 75 (setenta y cinco) expresados como un número base-10, número octal y número del hexadecimal, respectivamente.

Las constantes literales, como variables, se consideran tener un tipo de datos específico. Por

defecto, los literales del número entero están del tipo interno . Sin embargo, podemos

forzarlos a seamos sin firmar añadiendo el carácter de u a él, o largos añadiendo l :

75 // interno




7ü // interno sin firmar

75l // de largo

7ül // largo sin firmar

En ambos casos, el sufijo se puede especificar usando letras superiores o minúsculas.

Números De la Coma Flotante

Expresan números con decimales y/o exponentes. Pueden incluir o una coma, un carácter

de e (que exprese "por diez en la altura de Xth", donde está un valor X del número entero

que sigue el carácter de e), o una coma y un carácter de e:

3,14159 // 3,14159

6.0è23 // 6,02 x 1023

1.6e-19 // 1,6 x 10-19

3,0 // 3,0

Éstos son cuatro números válidos con los decimales expresados en C++. El primer número es pi, segundo es el número de Avogadro, el tercero es la carga eléctrica de un electrón (un número extremadamente pequeño) - todos aproximada y el pasado es el número tres expresado como literal numérico floating-point.

El tipo del defecto para los literales de la coma flotante es doble . Si usted desea

explícitamente expresar un flotador o un literal numérico doble largo, usted puede

utilizar la f o el l sufijos respectivamente:

3.14159L // de largo doble

6.0è23f // flotador

Cualesquiera de las letras que puede ser parte de una constante numérica floating-point ( e

, f , l) se pueden escribir usar más bajo o letras mayúsculas sin ninguna diferencia en sus

significados.

Carácter y literales de cadena

También existen las constantes no numéricas, como:

' z '

' p '

"hola mundo"

"cómo lo haga usted?"

Las primeras dos expresiones representan solas constantes de carácter, y los dos siguientes representan los literales de cadena integrados por varios caracteres. Note eso para representar un solo carácter que lo incluimos entre los apóstrofes ( ' ) y expresar una

secuencia (que consista en generalmente más de un carácter) lo incluimos entre las cotizaciones dobles ( ").




Al escribir el solo carácter y literales de cadena, es necesario poner las marcas de la cita que las rodean para distinguirlas de identificadores variables posibles o de palabras claves reservadas. Note la diferencia entre estas dos expresiones:

x

' x '

x solo referiría a una variable que identificador es x , mientras que ' x ' (incluido dentro

de marcas de sola cita) referiría a la constante de carácter ' x ' .

El carácter y los literales de cadena tienen ciertas particularidades, como los códigos del escape. Éstos son los caracteres especiales que son difíciles o imposibles expresar de otra

manera en el código de fuente de un programa, como el newline ( \n ) o la lengüeta ( \t

). Todos son precedidos por un backslash ( \ ). Aquí usted tiene una lista de algunos de

tales códigos del escape:

\n newline

\r retorno del carro

\t lengüeta

\v lengüeta vertical

\b tecla de retroceso

\f alimentación de forma (alimentación de página)

\a alarma (señal sonora)

\' apóstrofe ( ' )

\" cotización doble ( ")

\? ¿signo de interrogación (? )

\\ backslash ( \ )

Por ejemplo:

' \n '

' \t '

La "Derecha Dejada Del \t"

"one\ntwo\nthree"

Además, usted puede expresar cualquier carácter por su código numérico del ASCII

escribiendo un carácter del backslash ( \ ) seguido por el código del ASCII expresado como

número octal (base-8) o hexadecimal (base-16). En el primer caso (octal) los dígitos deben seguir inmediatamente el backslash (por ejemplo \23 o \40 ), en el segundo caso

(hexadecimal), un carácter de x se deben escribir antes de los dígitos ellos mismos (por

ejemplo \x20 o \xÂ ).

Los literales de cadena pueden extender más que una sola línea del código poniendo una

muestra del backslash ( \ ) en el extremo de cada línea inacabada.

"en expresado secuencia \ dos líneas"

Usted puede también concatenar varias constantes de la secuencia que las separan por un o vario espacios en blanco, los tabuladores, newline o cualquier otro carácter en blanco válido:

"esto forma"




"un solo"

"secuencia"

"de caracteres"

Finalmente, si quisiéramos que el literal de cadena fuera hecho explícitamente de los

caracteres anchos ( wchar_t ), en vez de los caracteres estrechos ( carbón ), podemos

preceder la constante con el L prefijo:

L "esto es una cadena de caracteres ancha"

Los caracteres anchos se utilizan principalmente para representar juegos de caracteres no-Ingleses o exóticos.

Literales boleanos

Hay solamente dos valores boleanos válidos: verdad y falso. Éstos se pueden expresar en

C++ como valores del bool del tipo usando los literales boleanos verdades y falsos .

Constantes definidas (# defina)

Usted puede definir sus propios nombres para las constantes que usted utiliza muy a menudo sin tener que recurrir a las variables memoria-que consumen, simplemente usando # define directorio del preprocesador. Su formato es:

# defina el valor del identificador

Por ejemplo:

# defina pi 3,14159265

# defina el NEWLINE ' \n '

Esto define dos nuevas constantes: Pi y NEWLINE . Una vez que se definan, usted puede

utilizarlos en el resto del código como si fueran cualquier otra constante regular, por ejemplo:

// constantes definidas: calcule

la circunferencia


el usar

namespace

std;

# defina pi 3,14159

# defina el NEWLINE ' \n ';

interno

cañería () {

doble

r=5.0; // radio

doble

31.4159




círculo; círculo = 2 * pi * r;

cout < < círculo; cout < <

NEWLINE;

vuelta

0; }

En hecho único cosa que recopilador preprocesador lo hacer cuando él encontrar # definir

directorio ser para literal substituir cualquier ocurrencia su identificador (en anterior ejemplo, éste ser pi y NEWLINE ) por código que tener ser definir ( 3,14159265 y ' \n '

respectivo).

# defina el directorio no es una declaración de C++ sino un directorio para el

preprocesador; por lo tanto asume la línea entera como el directorio y no requiere un punto y coma (; ) en su extremo. Si usted añade un carácter del punto y coma (; ) en el

extremo, también será añadido en todas las ocurrencias dentro del cuerpo del programa que el preprocesador substituye.

Constantes declaradas (const)

Con el prefijo del const usted puede declarar constantes con un específico mecanografía

de la misma manera que usted haría con una variable:

const

interno

pathwidth = 100;

const

carbón

tabulador = ' \t '

const

zipcode = 12440;

En caso de que ese tipo de no se especifique explícitamente (como en el ejemplo pasado) el

recopilador asume que está del tipo interno .

OPERADORES

Del una vez que sepamos de la existencia variables y las constantes, podemos comenzar a funcionar con ellas. Para ese propósito, C++ integra a operadores. Desemejante de otras idiomas que operadores sean principalmente palabras claves, hacen de las muestras que no son parte del alfabeto pero están disponibles los operadores en C++ sobre todo en todos los teclados. Esto hace código de C++ más corto y más internacional, puesto que confía menos en palabras inglesas, pero requiere un poco de esfuerzo el aprender en el principio.

Usted no tiene que memorizar todo el contenido de esta página. La mayoría de los detalles se proporcionan solamente al servicio como referencia más última en caso de que usted la necesite.

Assignation (=)

El operador del assignation asigna un valor a una variable.

a = 5;




Esta declaración asigna el valor 5 del número entero a la variable a . La parte a la izquierda

del operador del assignation ( = ) se conoce como el lvalue (valor izquierdo) y el derecho

como el rvalue (valor derecho). El lvalue tiene que ser una variable mientras que el rvalue puede ser una constante, una variable, el resultado de una operación o cualquier combinación de éstos. La regla más importante del assignation es la regla derecho-a-izquierda: La operación del assignation ocurre siempre el derecho a la izquierda, y nunca la otra manera:

a = b;

Esta declaración asigna a la variable a (el lvalue) el valor contenido en b variable (el

rvalue). El valor que fue almacenado hasta que este momento en a no se considera en

todos en esta operación, y en hecho de que el valor está perdido.

Considere también que estamos asignando solamente el valor de b a en el momento del

assignation. Por lo tanto un cambio más último de b no afectará el nuevo valor de a .

Por ejemplo, déjenos tienen una mirada en el código siguiente - he incluido la evolución del contenido almacenado en las variables como comentarios:

// operador del assignation


el usar

namespace

std;

interno

cañería () {

interna

a, b; // a:?, ¿b:?

a = 10; ¿//a:10, b:?

b = 4; // a:10, b:4

a = b; // a:4, b:4

b = 7; // a:4, b:7

cout < < "a:"

cout < < a; cout < < "b:"

cout < < b;

vuelta

0; }

a:4 b:7

Este código nos dará como resultado que el valor contenido en a sea 4 y el que esta'

contenido en b es 7 . Aviso cómo a no fue afectada por la modificación final de b ,

aunque declaramos a = b anterior (que está debido a la regla derecho-a-izquierda ).

Una característica que C++ tiene excedente otros lenguajes de programación es que la operación del assignation se puede utilizar como el rvalue (o parte de un rvalue) para otro assignation. Por ejemplo:




a = 2 + (b = 5);

es equivalente a:

b = 5; a = 2 + b;

eso significa: primero asigne 5 a b variable y en seguida asigne a el valor 2 más el

resultado del assignation anterior de b (es decir 5), dejando a con un valor final de 7 .

La expresión siguiente es también válida en C++:

a = b = c = 5;

Asigna 5 a todas las tres variables: a , b y c .

Operadores aritméticos (+, -, *, /, %es)

Las cinco operaciones aritméticas apoyadas por la lengua de C++ son:

+ adición

- substracción

* multiplicación

/ división

% modulo

Las operaciones de la adición, de la substracción, de la multiplicación y de la división corresponden literalmente con sus operadores matemáticos respectivos. El único que usted puede ser que no sea así que utilizado ver puede ser modulo ; de quién operador es la muestra del porcentaje ( % ). El modulo es la operación que da el resto de una división de

dos valores. Por ejemplo, si escribimos:

a = 11 %es 3;

la variable a contendrá el valor 2 , puesto que 2 es el resto de dividir 11 entre 3 .

Assignation compuesto (+ =, - =, * =,/=, %es =, > >

=, < < =, y =, ^ =,|=)

Cuando deseamos modificar el valor de una variable realizando una operación en el valor almacenado actualmente en que la variable nosotros puede utilizar a operadores compuestos del assignation:

expresión es equivalente a

valor + = aumento; valor = valor + aumento;

a - = 5; a = a - 5;

a/= b; a = a/b;

precio * = unidades + 1; precio = precio * (unidades + 1);

e iguales para el resto de los operadores. Por ejemplo:

// assignation del compund

5





el usar

namespace

std;

interno

cañería () {

interna

a, b=3; a = b; a+=2;

// equivalente a a=a+2

cout < < a;

vuelta

0; }

Aumente y disminuya (+ +, --)

Acortando aún más algunas expresiones, el operador del aumento ( ++ ) y el aumento del

operador de la disminución ( --) o reducen por uno el valor almacenado en una variable. Son

equivalentes a +=1 y a -=1 , respectivamente. Así:

c++; c+=1; c=c+1;

son todos equivalentes en su funcionalidad: los tres de ellos aumento por uno el valor de c.

En los recopiladores tempranos de C, las tres expresiones anteriores produjeron probablemente diverso código ejecutable dependiendo de el cual uno fue utilizado. Hoy en día, este tipo de optimización del código es hecho generalmente automáticamente por el recopilador, así las tres expresiones deben producir exactamente el mismo código ejecutable.

Una característica de este operador es que puede ser utilizada como prefijo y como sufijo. Eso significa que puede ser escrito antes del identificador variable ( ++a ) o después de él (

a++ ). Aunque en expresiones simples como a++ o ++a ambos tenga exactamente el

mismo significado, en otras expresiones en las cuales el resultado de la operación del aumento o de la disminución se evalúa mientras que un valor en una expresión externa ellos puede tener una diferencia importante en su significado: En el caso que utilizan al operador del aumento mientras que se aumenta un prefijo (++a) el valor antes de que el resultado de la expresión se evalúe y por lo tanto el valor creciente se considera en la expresión externa;

en caso de que se utilice eso él mientras que un sufijo ( a++ ) el valor almacenado en a se

aumenta después de ser evaluada y por lo tanto el valor almacenado antes de que la operación del aumento se evalúe en la expresión externa. Note la diferencia:

Ejemplo 1 Ejemplo 2

B=3;

A=++B;

// A contiene 4, B contiene 4

B=3;

A=B++;

// A contiene 3, B contiene 4

Del ejemplo 1, se aumenta B antes de que su valor se copie a A . Mientras que en el

ejemplo 2, el valor de B se copia a A y entonces a B se aumenta.

Operadores emparentados y de igualdad (==,! =, >, <,

> =, < =)

Para evaluar una comparación entre dos expresiones podemos utilizar a los operadores emparentados y de igualdad. El resultado de una operación emparentada es un valor boleano que puede solamente ser verdad o falso, según su resultado boleano.




Podemos desear comparar dos expresiones, por ejemplo, para saber si son iguales o si uno es mayor que el otro somos. Aquí está una lista de los operadores emparentados y de igualdad que pueden ser utilizados en C++:

== Igual a

!= No igual a

> Mayor que

< Menos que

>= Mayor que o igual a

<= Menos que o igual a

Aquí hay algunos ejemplos:

(7// evalúa del == 5) a falso.

(5 > 4) // evalúa para verdad.

(3! = 2) // evalúa para verdad.

(6 > = 6) // evalúa para verdad.

(5 < 5) // evalúa a falso.

Por supuesto, en vez de usar solamente constantes numéricas, podemos utilizar cualquier

expresión válida, incluyendo variables. Suponga que a=2 , b=3 y c=6 ,

(// evalúa del == 5) a falso puesto que a no es igual a 5.

(el a*b > = c) // evalúa para verdad puesto que (2*3 > = 6) es

verdad.

(b+4 > a*c) // evalúa a falso puesto que (3+4 > 2*6) es falso.

((b=2)// evalúa del == a) para verdad.

¡Tenga cuidado! El operador = (un igual) no es igual que el == del operador (dos

iguales), primer es operador del assignation (asigna el valor en la su derecha a la variable en su izquierda) y el otro ( == ) es el operador de igualdad que compara si ambas expresiones

en los dos lados de él son iguales el uno al otro. Así, en la expresión pasada (el == (b=2)

a) , primero asignamos el valor 2 a b y entonces lo comparamos a a , que también

almacena el valor 2 , así que el resultado de la operación es verdad.

Operadores lógicos (!, &&,||)

¡El Operador ! es el operador de C++ para realizar la operación boleana NO, él tiene

solamente un operando, situado en la su derecha, y la única cosa que lo hace es a lo contrario el valor de ella, el producir falso si su operando es verdad y verdad si su operando es falso. Básicamente, vuelve el valor boleano opuesto de evaluar su operando. Por ejemplo:

!(5// evalúa del == 5) a falso porque la expresión en la su

derecha (5 el == 5) es verdad.

< = 4) // evalúa para verdad porque (6 < = 4) serían falsos.

¡! verdad

// evalúa a falso




¡! falso

// evalúa para verdad.

El && lógico de los operadores y || se utilizan al evaluar dos expresiones obtener un

solo resultado emparentado. El && del operador corresponde con la operación lógica

boleana Y. Esta operación resulta verdad si sus dos operandos son verdades, y falso de otra manera. El panel siguiente demuestra el resultado del && del operador que evalúa la

expresión un && b :

OPERADOR del &&

a b un && b

verdad verdad verdad

verdad falso falso

falso verdad falso

falso falso falso

El operador || corresponde con la operación lógica boleana O. Esta operación resulta si

cualesquiera de sus dos operandos son verdades, así el ser falso falsa solamente cuando

ambos operandos son de hecho falsos. Aquí están los resultados posibles de a||b :

||OPERADOR

a b a||b

verdad verdad verdad

verdad falso verdad

falso verdad verdad

falso falso falso

Por ejemplo:

((5// evalúa del && del == 5) (3 > 6)) a falso (&& verdadero

falso).

((5 == 5)||(3 > 6)) // evalúa para verdad (verdad||falso).

¿Operador condicional (?

El operador condicional evalúa una expresión que vuelve un valor si esa expresión es verdad y diverso si la expresión se evalúa como falsa. Su formato es:

¿condición? result1: result2

Si la condición es verdad la expresión vuelve result1 , si no es volverá result2 .

¿7==5? 4: 3 // vueltas 3, puesto que 7 no es iguales a 5.

¿7==5+2? 4: 3 // vueltas 4, puesto que 7 es iguales a 5+2.

¿5>3? a: b // vueltas el valor de a, puesto que 5 es mayores

de 3.

¿a>b? a: b // vueltas cualquiera es mayor, a o b.




// operador condicional


el usar

namespace

std;

interno

cañería () {

interna

a, b, c; a=2; b=7; ¿c = (a>b)?

a: b; cout < < c;

vuelta

0; }

7

En este ejemplo a ser 2 y b ser 7 , así que expresión ser evaluar ( a>b ) ser no verdad,

así primero valor especificar después de que interrogación signo ser desechar en favor segundo valor (uno después dos puntos) que ser b , con uno valor 7 .

Operador de la coma ()

Utilizan al operador de la coma () para separar dos o más expresiones que sean incluidas

donde solamente una expresión espera. Cuando el sistema de expresiones tiene que ser evaluado para un valor, sólo se considera la expresión de derecha.

Por ejemplo, el código siguiente:

a = (b=3, b+2);

Primero asignaría el valor 3 a b , y en seguida asignan b+2 a la variable a . Así pues, en

el extremo, la variable a contendría el valor 5 mientras que b variable contendría el

valor 3 .

ENTRADA-SALIDA BÁSICA Hasta este momento, los programas del ejemplo de secciones anteriores proveieron de la interacción muy pequeña el usuario, si cualquiera en todos. Usando la biblioteca estándar de la entrada y de la salida, podremos obrar recíprocamente con el usuario imprimiendo mensajes en la pantalla y consiguiendo la entrada del usuario del teclado.

C++ utiliza una abstracción conveniente llamada las corrientes para realizar operaciones de la entrada y de salida en medios secuenciales tales como la pantalla o el teclado. Una corriente es un objeto donde un programa puede insertar o extraer los caracteres to/from él. Realmente no necesitamos cuidar sobre muchas especificaciones sobre los medios físicos asociados a la corriente - necesitamos solamente saber que acepte o que proporcione caracteres sequentialy.

La biblioteca estándar de C++ incluye el iostream del archivo de jefe , donde se declaran

los objetos estándares de la corriente de la entrada y de la salida.




Salida estándar (cout)

Por defecto, la salida estándar de un programa es la pantalla, y el objeto de la corriente de C++ definido para tenerle acceso es cout .

el cout se utiliza conjuntamente con el operador de la inserción , se escribe que como < <

(dos "menos que" muestras).

cout < < "oración hecha salir"

// oración de la salida de las impresiones en la pantalla

cout < < 120; // impresiones número 120 en la

pantalla

cout < < x; // impresiones el contenido de x en la

pantalla

< < el operador inserta los datos que lo siguen en la corriente que lo precede. En los

ejemplos sobre él insertó la oración constante de la salida de la secuencia , la

constante numérica 120 y x variable en el cout estándar de la corriente de la salida

. Note que la oración en la primera instrucción es incluida entre las cotizaciones dobles ( ")

porque es una cadena constante de caracteres. Siempre que deseemos utilizar cadenas

constantes de caracteres debemos incluirlos entre las cotizaciones dobles ( ") de modo que

puedan ser claramente distinguidos de nombres variables. Por ejemplo, estas dos oraciones tienen resultados muy diversos:

cout < < "hola"

// impresiones hola

cout < < hola; // impresiones el contenido hola de la variable

El operador de la inserción ( < < ) puede ser utilizado más de una vez en una sola

declaración:

cout < < "hola,"

< < "soy"

< < "una declaración de C++"

Esta última declaración imprimiría el mensaje hola, yo es una declaración de C++

sobre la pantalla. La utilidad de repetir al operador de la inserción ( < < ) se demuestra

cuando deseamos imprimir fuera de una combinación de variables y de constantes o más que una variable:

cout < < "hola, soy"

< < la edad < < los "años viejos y mi zipcode es"

< < zipcode;

Si asumimos la variable de la edad para contener el valor 24 y la variable del

zipcode para contener 90064 la salida de la declaración anterior sería:

Hola, soy 24 años de viejo y mi zipcode es 90064

Es importante notar que el cout no agrega una rotura de la línea después de su salida a

menos que la indiquemos explícitamente, por lo tanto, las declaraciones siguientes:




el cout < < "esto es una oración."

el cout < < "esto es otra oración."

será demostrado en la pantalla una después de la otra sin ninguna rotura de la línea entre ellos:

Esto es un sentence.This es otra oración.

aunque los habíamos escrito en dos diversas inserciones en cout . Para realizar una rotura

de la línea en la salida debemos insertar explícitamente un carácter de giro nuevo en cout .

En C++ un carácter de giro nuevo se puede especificar como \n (backslash, n):

cout < < "primer sentence.\n"

cout < < "segunda oración de sentence.\nThird."

Esto produce la salida siguiente:

Primera oración.

Segunda oración.

Tercera oración.

Además, agregar un de giro nuevo, usted puede también utilizar el manipulante del

endl. Por ejemplo:

cout < < "primera oración."

< < endl; cout < < "segunda oración."

< < endl;

imprimiría hacia fuera:

Primera oración.

Segunda oración.

El manipulante del endl produce un carácter del newline, exactamente como lo hace la

inserción del ' \n ', pero también tiene un comportamiento adicional cuando se utiliza con

las corrientes protegidas: se limpia con un chorro de agua el almacenador intermediario. De todas formas, el cout será una corriente inseparada en la mayoría de los casos, así que

usted puede utilizar generalmente ambos el carácter del escape del \n y el

manipulante del endl para especificar una nueva línea sin ninguna diferencia en su

comportamiento.

Entrada estándar (cin).

El dispositivo de entrada estándar es generalmente el teclado. La manipulación de la entrada

estándar en C++ es hecha aplicando al operador sobrecargado de la extracción ( > > ) en

la corriente del cin. El operador debe ser seguido por la variable que almacenará los

datos que van a ser extraídos de la corriente. Por ejemplo:

interno

edad; cin > > edad;

La primera declaración declara una variable de la edad llamada interna del tipo , y

segunda espera una entrada del cin (el teclado) para almacenarlo en esta variable de

número entero.




el cin puede procesar solamente la entrada del teclado una vez que se haya

presionado la llave DE VUELTA. Por lo tanto, iguale si usted solicita un solo carácter, la

extracción del cin no procesará la entrada hasta que las prensas del usuario VUELVEN

después de que se haya introducido el carácter.

Usted debe considerar siempre el tipo de la variable que usted está utilizando como envase con las extracciones del cin. Si usted solicita un número entero que usted conseguirá

un número entero, si usted solicita un carácter usted conseguirá un carácter y si usted solicita una cadena de caracteres usted conseguirá una cadena de caracteres.

ejemplo// i/o


el usar

namespace

std;

interno

cañería () {

interna

i; el cout < < "incorpora por

favor un valor del número entero:

"

cin > > i; el cout < < "el

valor que usted incorporó es"

< < i; el cout < < "y su doble

es"

< < i*2 < < "\n"

vuelta

0; }

Incorpore por favor un valor del

número entero: 702 el valor que

usted incorporó es 702 y su doble

es 1404.

El usuario de un programa puede ser uno de los factores que generan errores incluso en los

programas más simples que utilizan el cin (como el que acabamos de ver). Desde

entonces si usted solicita un valor del número entero y el usuario introduce un nombre (que sea generalmente una cadena de caracteres), el resultado puede causar su programa al misoperate puesto que no es lo que esperábamos del usuario. Tan cuando usted utiliza la entrada de datos proporcionada por las extracciones del cin usted tendrá que confiar

en que el usuario de su programa será cooperativo y que he/she no introducirá su nombre o

algo similar cuando se solicita un valor del interger. Poco a continuación, cuando vemos el

stringstream clasificarnos voluntad veremos una solución posible para los errores que se

pueden causar por este tipo de entrada del usuario.

Usted puede también utilizar el cin para solicitar más de un dato entrado del usuario:

cin > > a > > b;

es equivalente a:

cin > > a; cin > > b;

En ambos casos el usuario debe dar dos datos, uno para la variable a y otro para b

variable que se pueda separar por cualquier separador en blanco válido: un espacio, un

carácter de lengüeta o un newline.




cin y secuencias

Podemos utilizar el cin para conseguir secuencias con el operador de la extracción ( > >

) como hacemos con variables fundamentales del tipo de datos:

cin > > mystring;

Sin embargo, como se ha dicho, la extracción del cin para el leer tan pronto como si los

hallazgos cualquier carácter de espacio en blanco, así que en este caso nosotros pueden conseguir apenas una palabra para cada extracción. Este comportamiento puede o puede no ser lo que deseamos; por ejemplo si deseamos conseguir una oración del usuario, esta operación de la extracción no sería útil.

Para conseguir líneas enteras, podemos utilizar el getline de la función , que es la

manera más recomendable de conseguir a usuario entrar con el cin :

// cin con las secuencias


# incluya la < secuencia >

el usar

namespace

std;

interno

cañería () { mystr de la secuencia;

¿el cout < < "cuál es su nombre?

"

getline (cin, mystr); cout < <

"hola"

< < mystr < < "\n"

¿el cout < < "cuál es su equipo

preferido? "

getline (cin, mystr); cout < <

"tengo gusto"

< < mystr < < "too!\n"

vuelta

0; }

¿Cuál es su nombre? Juan Soulié

Hola Juan Soulié. ¿Cuál es su

equipo preferido? ¡cLa Lakers

tengo gusto del LA Lakers también!

Aviso cómo en ambas llamadas al getline utilizamos el mismo identificador de la

secuencia ( mystr ). Qué el programa hace en la segunda llamada debe simplemente

substituir el contenido anterior por el nuevo se introduce que.

stringstream

El archivo de jefe estándar < sstream > define una clase llamada el stringstream que

permite que un objeto secuencia-basado sea tratado como corriente. Esta manera podemos realizar secuencias de las operaciones from/to de la extracción o de la inserción, que es especialmente útil para convertir secuencias a los valores numéricos y viceversa. Por ejemplo, si deseamos extraer un número entero de una secuencia podemos escribir:

mystr de la secuencia ("1204"

interno

myint; stringstream(mystr) > > myint;




Esto declara un objeto de la secuencia con un valor de "1204" , y un objeto interno.

Entonces utilizamos constructor de s del stringstream ' para construir un objeto de este

tipo del objeto de la secuencia. Porque podemos utilizar objetos del stringstrem como si

fueran corrientes, podemos extraer un número entero de él pues habríamos hecho en cin

aplicando el extractor que el operador ( > > ) en él siguió por una variable del tipo

interna .

Después de este pedazo del código, el myint variable contendrá el valor numérico 1204 .

// stringstreams


# incluya la < secuencia >

# incluya el < sstream >

el usar

namespace

std;

interno

cañería () { mystr de la secuencia;

flotador

price=0;

interno

quantity=0; el cout < <

"incorpora precio: "

getline (cin, mystr);

stringstream(mystr) > > precio; el

cout < < "incorpora cantidad: "

getline (cin, mystr);

stringstream(mystr) > > cantidad;

cout < < "precio total: "

< < price*quantity < < endl;

vuelta

0; }

Incorpore el precio: 22,25

Incorpore la cantidad: precio

total 7: 155,75

En este ejemplo, adquirimos valores numéricos de la entrada estándar indirectamente. En vez de extraer valores numéricos directamente de la entrada estándar, conseguimos líneas de la entrada estándar ( cin ) en un objeto de la secuencia ( mystr ), y entonces

extraemos los valores del número entero de esta secuencia en una variable del tipo interna (

myint ).

Usando este método, en vez de extracciones directas de los valores del número entero, tenemos más control sobre qué sucede con la entrada de valores numéricos del usuario, puesto que estamos separando el proceso de obtener la entrada del usuario (ahora pedimos simplemente líneas) con la interpretación de esa entrada. Por lo tanto, le recomiendo para utilizar este método en vez de la extracción directa para conseguir valores numéricos del usuario en todos los programas que sean intensivos en entrada del usuario.

Documents

Estructura de un programa+.pdfEstructura de un programa Probablemente la mejor manera de comenzar a aprender un lenguaje de programación está escribiendo un programa. Por lo tanto,