Pensar en C++ (Volumen 1) - Grupo ARCO
Pensar en C++ (Volumen 1) - Grupo ARCO Pensar en C++ (Volumen 1) - Grupo ARCO
✐ ✐ ✐ “Volumen1” — 2012/1/12 — 13:52 — page 74 — #112 ✐ Capítulo 3. C en C++ 3.2.9. Recursividad La recursividad es una técnica de programación interesante y a veces útil, en donde se llama a la función desde el cuerpo de la propia función. Por supuesto, si eso es todo lo que hace, se estaría llamando a la función hasta que se acabase la memoria de ejecución, de modo que debe existir una manera de «escaparse» de la llamada recursiva. En el siguiente ejemplo, esta «escapada» se consigue simplemente indicando que la recursión sólo continuará hasta que cat exceda Z: 2 //: C03:CatsInHats.cpp // Simple demonstration of recursion #include using namespace std; void removeHat(char cat) { for(char c = ’A’; c < cat; c++) cout
✐ ✐ ✐ “Volumen1” — 2012/1/12 — 13:52 — page 75 — #113 ✐ 3.3. Introducción a los operadores 3.3.1. Precedencia La precedencia de operadores define el orden en el que se evalúa una expresión con varios operadores diferentes. C y C++ tienen reglas específicas para determinar el orden de evaluación. Lo más fácil de recordar es que la multiplicación y la división se ejecutan antes que la suma y la resta. Luego, si una expresión no es transparente al programador que la escribe, probablemente tampoco lo será para nadie que lea el código, de modo que se deben usar paréntesis para hacer explícito el orden de la evaluación. Por ejemplo: A = X + Y - 2/2 + Z; Tiene un significado muy distinto de la misma expresión pero con un configuración de paréntesis particular: A = X + (Y - 2)/(2 + Z); (Intente evaluar el resultado con X =1, Y = 2, y Z = 3.) 3.3.2. Auto incremento y decremento C, y por tanto C++, está lleno de atajos. Los atajos pueden hacer el código mucho mas fácil de escribir, y a veces más difícil de leer. Quizás los diseñadores del lenguaje C pensaron que sería más fácil entender un trozo de código complicado si los ojos no tienen que leer una larga línea de letras. Los operadores de auto-incremento y auto-decremento son de los mejores atajos. Se utilizan a menudo para modificar las variables que controlan el número de veces que se ejecuta un bucle. El operador de auto-decremento es -- que significa «decrementar de a una unidad». El operador de auto-incremento es ++ que significa «incrementar de a una unidad». Si es un entero, por ejemplo, la expresión ++A es equivalente a (A = A + 1). Los operadores de auto-incremento y auto-decremento producen el valor de la variable como resultado. Si el operador aparece antes de la variable (p.ej, ++A), la operación se ejecuta primero y después se produce el valor resultante. Si el operador aparece a continuación de la variable (p.ej, A++), primero se produce el valor actual, y luego se realiza la operación. Por ejemplo: //: C03:AutoIncrement.cpp // Shows use of auto-increment // and auto-decrement operators. #include using namespace std; int main() { int i = 0; int j = 0; cout
- Page 61 and 62: ✐ ✐ ✐ “Volumen1” — 2012
- Page 63 and 64: ✐ ✐ ✐ “Volumen1” — 2012
- Page 65 and 66: ✐ ✐ ✐ “Volumen1” — 2012
- Page 67 and 68: ✐ ✐ ✐ “Volumen1” — 2012
- Page 69 and 70: ✐ ✐ ✐ “Volumen1” — 2012
- Page 71 and 72: ✐ ✐ ✐ “Volumen1” — 2012
- Page 73 and 74: ✐ ✐ ✐ “Volumen1” — 2012
- Page 75 and 76: ✐ ✐ ✐ “Volumen1” — 2012
- Page 77 and 78: ✐ ✐ ✐ “Volumen1” — 2012
- Page 79 and 80: ✐ ✐ ✐ “Volumen1” — 2012
- Page 81 and 82: ✐ ✐ ✐ “Volumen1” — 2012
- Page 83 and 84: ✐ ✐ ✐ “Volumen1” — 2012
- Page 85 and 86: ✐ ✐ ✐ “Volumen1” — 2012
- Page 87 and 88: ✐ ✐ ✐ “Volumen1” — 2012
- Page 89 and 90: ✐ ✐ ✐ “Volumen1” — 2012
- Page 91 and 92: ✐ ✐ ✐ “Volumen1” — 2012
- Page 93 and 94: ✐ ✐ ✐ “Volumen1” — 2012
- Page 95 and 96: ✐ ✐ ✐ “Volumen1” — 2012
- Page 97 and 98: ✐ ✐ ✐ “Volumen1” — 2012
- Page 99 and 100: ✐ ✐ ✐ “Volumen1” — 2012
- Page 101 and 102: ✐ ✐ ✐ “Volumen1” — 2012
- Page 103 and 104: ✐ ✐ ✐ “Volumen1” — 2012
- Page 105 and 106: ✐ ✐ ✐ “Volumen1” — 2012
- Page 107 and 108: ✐ ✐ ✐ “Volumen1” — 2012
- Page 109 and 110: ✐ ✐ ✐ “Volumen1” — 2012
- Page 111: ✐ ✐ ✐ “Volumen1” — 2012
- Page 115 and 116: ✐ ✐ ✐ “Volumen1” — 2012
- Page 117 and 118: ✐ ✐ ✐ “Volumen1” — 2012
- Page 119 and 120: ✐ ✐ ✐ “Volumen1” — 2012
- Page 121 and 122: ✐ ✐ ✐ “Volumen1” — 2012
- Page 123 and 124: ✐ ✐ ✐ “Volumen1” — 2012
- Page 125 and 126: ✐ ✐ ✐ “Volumen1” — 2012
- Page 127 and 128: ✐ ✐ ✐ “Volumen1” — 2012
- Page 129 and 130: ✐ ✐ ✐ “Volumen1” — 2012
- Page 131 and 132: ✐ ✐ ✐ “Volumen1” — 2012
- Page 133 and 134: ✐ ✐ ✐ “Volumen1” — 2012
- Page 135 and 136: ✐ ✐ ✐ “Volumen1” — 2012
- Page 137 and 138: ✐ ✐ ✐ “Volumen1” — 2012
- Page 139 and 140: ✐ ✐ ✐ “Volumen1” — 2012
- Page 141 and 142: ✐ ✐ ✐ “Volumen1” — 2012
- Page 143 and 144: ✐ ✐ ✐ “Volumen1” — 2012
- Page 145 and 146: ✐ ✐ ✐ “Volumen1” — 2012
- Page 147 and 148: ✐ ✐ ✐ “Volumen1” — 2012
- Page 149 and 150: ✐ ✐ ✐ “Volumen1” — 2012
- Page 151 and 152: ✐ ✐ ✐ “Volumen1” — 2012
- Page 153 and 154: ✐ ✐ ✐ “Volumen1” — 2012
- Page 155 and 156: ✐ ✐ ✐ “Volumen1” — 2012
- Page 157 and 158: ✐ ✐ ✐ “Volumen1” — 2012
- Page 159 and 160: ✐ ✐ ✐ “Volumen1” — 2012
- Page 161 and 162: ✐ ✐ ✐ “Volumen1” — 2012
✐<br />
✐<br />
✐<br />
“Volum<strong>en</strong>1” — 2012/1/12 — 13:52 — page 74 — #112<br />
✐<br />
Capítulo 3. C <strong>en</strong> <strong>C++</strong><br />
3.2.9. Recursividad<br />
La recursividad es una técnica de programación interesante y a veces útil, <strong>en</strong><br />
donde se llama a la función desde el cuerpo de la propia función. Por supuesto, si<br />
eso es todo lo que hace, se estaría llamando a la función hasta que se acabase la<br />
memoria de ejecución, de modo que debe existir una manera de «escaparse» de la<br />
llamada recursiva. En el sigui<strong>en</strong>te ejemplo, esta «escapada» se consigue simplem<strong>en</strong>te<br />
indicando que la recursión sólo continuará hasta que cat exceda Z: 2<br />
//: C03:CatsInHats.cpp<br />
// Simple demonstration of recursion<br />
#include <br />
using namespace std;<br />
void removeHat(char cat) {<br />
for(char c = ’A’; c < cat; c++)<br />
cout