Tutorial jared

TUTORIAL DE C++
Hugo Jared Sánchez Martínez

INTRODUCCIÓN
C ++ utiliza los siguientes tipos de datos fundamentales
• Caracteres: char (también es un entero), wchart_t
• Enteros: short, int, ling, doublé, long doublé
• Booleanos: bool
• Vacío: void

INTRODUCCIÓN
Informacion y Conocimiento son los dos elementos claves del nuevo milenio ninguna sociedad
podra alcanzar ni puede ignorar este nuevo esquema ya las naciones no se miden por su riqueza
industrial, ni sus activos fisicos, ni por su poder militar, sino por la cantidad de informacion que
produce y consume, asi como por la recombinacion de informacion nueva en un conocimiento de
grado superior.

LA PALABRA
RESERVADA “VOID”
La palabra reservada void es el concepto de no existencia o no
atribución de un tipo en una variable o declaración. Esta palabra
reservada también puede usarse para indicar que una función no
recibe parámetros, como en la siguiente declaración:
int función (void) ;

USO DE LA PALABRA
“NULL”
Además de los valores que pueden tomar los tipos anteriormente
mencionados, existe un valor llamado NULL, sea el caso numérico para
los enteros, carácter para el tipo char, cadena de texto para el tipo
string, etc. El valor NULL, expresa, por lo regular, la representación
de una Macro, asignada al valor "0“ tenemos entonces que:
void* puntero = NULL;
int entero = NULL;
bool boleana = NULL;
char caracter = NULL;

PRINCIPIOS
Todo programa en C++ debe tener la función principal main() (a no ser que se especifique en tiempo de
compilación otro punto de entrada, que en realidad es la función que tiene el main())
int main()
{}
La función principal del código fuente main debe tener uno de los siguientes prototipos:
int main()
int main(int argc, char** argv)
Aunque no es estándar algunas implementaciones permiten
int main(int argc, char** argv, char** env)
La primera es la forma por omisión de un programa que no recibe parámetros ni argumentos. La segunda
forma tiene dos parámetros: argc, un número que describe el número de argumentos del programa
(incluyendo el nombre del programa mismo), y argv, un puntero a un array de punteros, de argc elementos,
donde el elemento argv[i] representa el i-ésimo argumento entregado al programa. En el tercer caso se
añade la posibilidad de poder acceder a las variables de entorno de ejecución de la misma forma que se
accede a los argumentos del programa, pero reflejados sobre la variable env.
El tipo de retorno de main es un valor entero int. Al finalizar la función main, debe incluirse el valor de
retorno (por ejemplo, return 0;, aunque el estándar prevé solamente dos posibles valores de retorno:
EXIT_SUCCESS y EXIT_FAILURE, definidas en el archivo cstdlib), o salir por medio de la función exit.
Alternativamente puede dejarse en blanco, en cuyo caso el compilador es responsable de agregar la salida
adecuada.

VARIABLES
Identificadores son conjuntos de letras y/o numeros que se utilizan para simbolizar
todos los elementos que en un programa son definibles por el usuario (programador o
ingeniero de software) del mismo como son las variables donde se almacenan datos,
funciones( pequenos modulos con codigo), etiquetas, clases, objetos, etc.
Una variable se define como un identificador que se utiliza para almacenar todos los
datos generados durante la ejecucion de un programa.

REGLAS DE VARIABLES
• Existen ciertas reglas en cuanto a variables:
• Claras y con referencia directa al problema.
• No espacios en blanco, ni simbolos extranos en ellas.
• Se pueden usar abreviaturas, pero solo de caracter general.
• No deben ser palabras reservadas del lenguaje.

EJEMPLOS DE VARIABLES
Nombre, Edad, SdoDiario, IngMensual, Perimetro, Calif1, etc.

JERARQUÍA DE
OPERACIONES
El problema de no tomar en cuenta la jerarquia de los operadores al plantear y resolver una operacion casi siempre
conduce a resultados muchas veces equivocados como estos:
Ejemplos: a) 2 + 3 * 4 = 20 (incorrecto)
…………………..= 14 (correcto)

EJEMPLOS DE JERARQUÍA
si calif1=60 y calif2=80
entonces si en programa se usa
promedio=calif1 + calif2/2
da como resultado promedio = 100

Los destructores son invocados automáticamente al alcanzar el
flujo del programa el fin del ámbito en el que está declarado el
objeto. El único caso en el que se debe invocar explícitamente al
destructor de un objeto, es cuando este fue creado mediante el
operador new, es decir, que este vive en memoria heap, y no en la
pila de ejecución del programa. La invocación del destructor de
un objeto que vive en heap se realiza a través del operador
delete o delete[] para arrays.

ORDEN DE OPERACIONES
1.- Parentesis
2.- Potencias y raices
3.- Multiplicaciones y divisiones
4.- Sumas y restas
5.- Dos o mas de la misma jerarquia u orden entonces resolver de izquierda a derecha
Nota: Si se quiere alterar el orden normal de operaciones entonces usar parentesis.
Nota: Tampoco es bueno usar parentesis de mas en una operacion esto solo indica que no se evaluo bien la formula como en el siguiente
ejemplo;
<m> area = ( base * altura ) / 2 </m>

FUNCIONES MIEMBRO
Función miembro es aquella que está declarada en ámbito de clase. Son similares a
las funciones habituales, con la salvedad de que el compilador realizara el proceso
de Decoración de nombre (Name Mangling en inglés): Cambiará el nombre de la
función añadiendo un identificador de la clase en la que está declarada, pudiendo
incluir caracteres especiales o identificadores numéricos. Este proceso es invisible
al programador. Además, las funciones miembro reciben implícitamente un
parámetro adicional: El puntero this, que referencia al objeto que ejecuta la
función.
Las funciones miembro se invocan accediendo primero al objeto al cual refieren, con
la sintaxis: myobject.mymemberfunction(), esto es un claro ejemplo de una función
miembro.
Caso especial es el de las funciones miembro estáticas. A pesar de que son
declaradas dentro de la clase, con el uso de la palabra clave static no recibirán el
puntero this. Gracias a esto no es necesario crear ninguna instancia de la clase para
llamar a esta función, sin embargo, solo se podrá acceder a los miembros estáticos
de la clase dado que estos no están asociados al objeto sino al tipo. La sintaxis para
llamar a esta función estática es mytype::mystaticmember().

PLANTILLAS
Las plantillas son el mecanismo de C++ para implantar el
paradigma de la programación genérica. Permiten que una clase o
función trabaje con tipos de datos abstractos, especificándose
más adelante cuales son los que se quieren usar. Por ejemplo, es
posible construir un vector genérico que pueda contener
cualquier tipo de estructura de datos. De esta forma se pueden
declarar objetos de la clase de este vector que contengan
enteros, flotantes, polígonos, figuras, fichas de personal, etc.
La declaración de una plantilla se realiza anteponiendo la
declaración template <typename A,....> a la declaración de la
estructura (clase, estructura o función) deseado.

ESPECIALIZACIÓN
El siguiente ejemplo:
template <typename A> int myfunction(A a);
crea una plantilla bajo la cual pueden ser definidas en el código
de cabecera cualesquiera funciones especializadas para un tipo
de datos como int myfunction(int), int myfunction(std::string),
int myfunction(bool), etcétera:

Cada una de estas funciones tiene su propia definición (cuerpo). Cada
cuerpo diferente, no equivalente ("no convertible") corresponde a una
especialización. Si una de estas funciones no fuera definida, el
compilador tratará de aplicar las conversiones de tipos de datos que
le fuesen permitidas para "calzar" una de las plantillas, o generará un
mensaje de error si fracasa en ese proceso.
Todas las definiciones habilitadas de una plantilla deben estar
disponibles al momento de la compilación, por lo cual no es posible
actualmente "compilar" una plantilla como archivo de objeto, sino
simplemente compilar especializaciones de la plantilla. Por lo tanto, las
plantillas se distribuyen junto con el código fuente de la aplicación. En
otras palabras, no es posible compilar la plantilla std::vector< > a
código objeto, pero sí es posible, por ejemplo, compilar un tipo de
datos std::vector<std::string>.

CLASES ABSTRACTAS
En C++ es posible definir clases abstractas. Una clase abstracta, o clase
base abstracta (ABC), es una que está diseñada solo como clase padre de las
cuales se deben derivar clases hijas. Una clase abstracta se usa para
representar aquellas entidades o métodos que después se implementarán en
las clases derivadas, pero la clase abstracta en sí no contiene ninguna
implementación -- solamente representa los métodos que se deben
implementar. Por ello, no es posible instanciar una clase abstracta, pero sí
una clase concreta que implemente los métodos definidos en ella.
Las clases abstractas son útiles para definir interfaces, es decir, un
conjunto de métodos que definen el comportamiento de un módulo
determinado. Estas definiciones pueden utilizarse sin tener en cuenta la
implementación que se hará de ellos.
En C++ los métodos de las clases abstractas se definen como funciones
virtuales puras.

ESPACIOS DE NOMBRES
Una adición a las características de C son los espacios de nombre
(namespace en inglés), los cuales pueden describirse como áreas
virtuales bajo las cuales ciertos nombres de variable o tipos tienen
validez. Esto permite evitar las ocurrencias de conflictos entre
nombres de funciones, variables o clases.
El ejemplo más conocido en C++ es el espacio de nombres std::, el cual
almacena todas las definiciones nuevas en C++ que difieren de C
(algunas estructuras y funciones), así como las funcionalidades propias
de C++ (streams) y los componentes de la biblioteca STL.

Como puede verse, las invocaciones directas a mi_valor darán
acceso solamente a la variable descrita localmente; para acceder
a la variable del espacio de nombres mi_paquete es necesario
acceder específicamente el espacio de nombres. Un atajo
recomendado para programas sencillos es la directiva using
namespace, que permite acceder a los nombres de variables del
paquete deseado en forma directa, siempre y cuando no se
produzca alguna ambigüedad o conflicto de nombres.

HERENCIA
Existen varios tipos de herencia entre clases en el lenguaje de
programación C++. Estos son:

HERENCIA SIMPLE
La herencia en C++ es un mecanismo de abstracción creado para poder
facilitar y mejorar el diseño de las clases de un programa. Con ella se
pueden crear nuevas clases a partir de clases ya hechas, siempre y cuando
tengan un tipo de relación especial.
En la herencia, las clases derivadas "heredan" los datos y las funciones
miembro de las clases base, pudiendo las clases derivadas redefinir estos
comportamientos (polimorfismo) y añadir comportamientos nuevos
propios de las clases derivadas. Para no romper el principio de
encapsulamiento (ocultar datos cuyo conocimiento no es necesario para
el uso de las clases), se proporciona un nuevo modo de visibilidad de los
datos/funciones: "protected". Cualquier cosa que tenga visibilidad
protected se comportará como pública en la clase Base y en las que
componen la jerarquía de herencia, y como privada en las clases que NO
sean de la jerarquía de la herencia.

Antes de utilizar la herencia, nos tenemos que hacer una
pregunta, y si tiene sentido, podemos intentar usar esta
jerarquía: Si la frase <claseB> ES-UN <claseA> tiene sentido,
entonces estamos ante un posible caso de herencia donde clase
A será la clase base y clase B la derivada.
Ejemplo: clases Barco, Acorazado, Carguero, etc. Un Acorazado
ES-UN Barco, un Carguero ES-UN Barco, un Trasatlántico ES-
UN Barco, etc.
En este ejemplo tendríamos las cosas generales de un Barco (en
C++)

En este ejemplo tendríamos las cosas generales de un Barco (en
C++)
class Barco {
protected:
char* nombre;
float peso;
public:
//Constructores y demás funciones básicas de barco
};

y ahora las características de las clases derivadas, podrían (a la vez que heredan las
de barco) añadir cosas propias del subtipo de barco que vamos a crear, por ejemplo:
class Carguero: public Barco { // Esta es la manera de especificar que hereda de
Barco
private:
float carga;
//El resto de cosas
};
class Acorazado: public Barco {
private:
int numeroArmas;
int Soldados;
// El resto de cosas
};

Por último, hay que mencionar que existen 3 clases de herencia
que se diferencian en el modo de manejar la visibilidad de los
componentes de la clase resultante:
• Herencia pública (class Derivada: public Base ): Con este tipo
de herencia se respetan los comportamientos originales de las
visibilidades de la clase Base en la clase Derivada.
• Herencia privada (clase Derivada: private Base): Con este tipo
de herencia todo componente de la clase Base, será privado en
la clase Derivada (las propiedades heredadas serán privadas
aunque estas sean públicas en la clase Base)
• Herencia protegida (clase Derivada: protected Base): Con este
tipo de herencia, todo componente público y protegido de la
clase Base, será protegido en la clase Derivada, y los
componentes privados, siguen siendo privados.

HERENCIA MÚLTIPLE
La herencia múltiple es el mecanismo que permite al
programador hacer clases derivadas a partir, no de una sola
clase base, sino de varias. Para entender esto mejor, pongamos
un ejemplo: Cuando ves a quien te atiende en una tienda, como
persona que es, podrás suponer que puede hablar, comer, andar,
pero, por otro lado, como empleado que es, también podrás
suponer que tiene un jefe, que puede cobrarte dinero por la
compra, que puede devolverte el cambio, etc.

Si esto lo trasladamos a la programación sería herencia múltiple (clase empleado tienda):
class Persona {
...
Hablar();
Caminar();
...
};
class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
}class EmpleadoTienda: public Persona, Empleado {
...AlmacenarStock();
ComprobarExistencias();
...
};

SOBRECARGA DE
OPERADORES
La sobrecarga de operadores es una forma de hacer polimorfismo. Es
posible definir el comportamiento de un operador del lenguaje para
que trabaje con tipos de datos definidos por el usuario. No todos los
operadores de C++ son factibles de sobrecargar, y, entre aquellos que
pueden ser sobrecargados, se deben cumplir condiciones especiales.
En particular, los operadores sizeof y :: no son sobrecargables.
No es posible en C++ crear un operador nuevo.
Los comportamientos de los operadores sobrecargados se
implementan de la misma manera que una función, salvo que esta
tendrá un nombre especial: Tipo de dato de devolución operator<token
del operador>(parámetros)

Los siguientes operadores pueden ser sobrecargados:
Operadores Unarios
Operador * (de indirección)
Operador -> (de indirección)
Operador & (de dirección)
Operador +
Operador -
Operador ++
Operador --
Operadores Binarios

Operador ==
Operador +
Operador -
Operador *
Operador /
Operador %
Operador <<
Operador >>
Operador &

Operador ^
Operador |
Operador []
Operador ()
Operadores de Asignación
Operador =
Operador +=
Operador -=

Operador *=
Operador /=
Operador %=
Operador <<=
Operador >>=
Operador &=
Operador ^=
Operador |=

Dado que estos operadores son definidos para un tipo de datos
definido por el usuario, este es libre de asignarles cualquiera
semántica que desee. Sin embargo, se considera de primera
importancia que las semánticas sean tan parecidas al comportamiento
natural de los operadores como para que el uso de los operadores
sobrecargados sea intuitivo. Por ejemplo, el uso del operador unario -
debiera cambiar el "signo" de un "valor".
Los operadores sobrecargados no dejan de ser funciones, por lo que
pueden devolver un valor, si este valor es del tipo de datos con el que
trabaja el operador, permite el encadenamiento de sentencias. Por
ejemplo, si tenemos 3 variables A, B y C de un tipo T y sobrecargamos
el operador = para que trabaje con el tipo de datos T, hay dos
opciones: si el operador no devuelve nada una sentencia como "A=B=C;"
(sin las comillas) daría error, pero si se devuelve un tipo de datos T al
implementar el operador, permitiría concatenar cuantos elementos se
quisieran, permitiendo algo como "A=B=C=D=...;"

STANDART TEMPLATE
LIBRARY (STL)
Los lenguajes de programación suelen tener una serie de
bibliotecas de funciones integradas para la manipulación de
datos a nivel más básico. En C++, además de poder usar las
bibliotecas de C, se puede usar la nativa STL (Standard
Template Library), propia del lenguaje. Proporciona una serie
plantillas (templates) que permiten efectuar operaciones sobre
el almacenado de datos, procesado de entrada/salida.

BIBLIOTECA DE ENTRADA Y
SALIDA
Las clases basic_ostream y basic_stream, y los objetos cout y
cin, proporcionan la entrada y salida estándar de datos
(teclado/pantalla). También está disponible cerr, similar a cout,
usado para la salida estándar de errores. Estas clases tienen
sobrecargados los operadores << y >>, respectivamente, con el
objeto de ser útiles en la inserción/extracción de datos a dichos
flujos. Son operadores inteligentes, ya que son capaces de
adaptarse al tipo de datos que reciben, aunque tendremos que
definir el comportamiento de dicha entrada/salida para
clases/tipos de datos definidos por el usuario

Por ejemplo:
ostream& operator<<(ostream& fs, const Punto& punto)
{
return fs << punto.x << "," << punto.y;
}

De esta forma, para mostrar un punto, solo habría que realizar la
siguiente expresión:
//...
Punto p(4,5);
//...
cout << "Las coordenadas son: " << p << endl;
//...
Es posible formatear la entrada/salida, indicando el número de
dígitos decimales a mostrar, si los textos se pasarán a
minúsculas o mayúsculas, si los números recibidos están en
formato octal o hexadecimal, etc.

FSTREAMS
Tipo de flujo para el manejo de ficheros. La definición previa
de ostreams/istreams es aplicable a este apartado. Existen tres
clases (ficheros de lectura, de escritura o de lectura/escritura)

IFSTREAM, OFSTREAM Y
FSTREAM
Como abrir un fichero:
(nombre_variable_fichero).open("nombre_fichero.dat/txt",
ios::in); para abrirlo en modo lectura.
(nombrevariablefichero).open("nombre_fichero.dat/txt",
ios::out); para abrirlo en modo escritura.

1-Si es fichero de texto plano:
#include <fstream>
#include <string>
#include <iostream>
using namespace std;
int main() {
ifstream entrada;
entrada.open("textoPlano.txt");
string unString;
while(entrada >> unString)
cout << "Lei: " << unString << endl;
return 0;
}

2-Si es un fichero binario(.dat);
nombre_variable_fichero.read((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.read((char*)&e, sizeof(int));

ESCRIBIR UN FICHERO
1-Si es fichero de texto(.txt):
nombrevariable<<"texto"; donde "texto" puede ser también una
variable de cualquier tipo primitivo, o un string.
Ejemplo: f<<HOLA;

2-Si es un fichero binario(.dat);
nombre_variable_fichero.write((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.write((char*)&e, sizeof(int));
Pueden abrirse pasando al constructor los parámetros relativos
a la ubicación del fichero y el modo de apertura:

SSTREAMS
Se destacan dos clases, ostringstream e istringstream. Todo lo
anteriormente dicho es aplicable a estas clases. Tratan a una cadena
como si de un flujo de datos se tratase. ostringstream permite
elaborar una cadena de texto insertando datos cual flujo, e
istringstream puede extraer la información contenida en una cadena
(pasada como parámetro en su constructor) con el operador >>.
Ejemplos:
ostringstream s;
s << nombre << "," << edad << "," << estatura << "," << punto(5,6) << endl;
cout << s.str();
istringstream s(cadena);
s >> nombre >> edad >> estatura >> p;

CONTENEDORES
Son clases plantillas especiales utilizadas para almacenar tipos
de datos genéricos, sean cuales sean. Todos los contenedores
son homogéneos, es decir, una vez que se declaran para contener
un tipo de dato determinado, en ese contenedor, solo se podrán
meter elementos de ese tipo. Según la naturaleza del
almacenado, disponemos de varios tipos:
Vectores: Se definen por
vector<tipo_de_dato> nombre_del_vector;

Son arrays (o listas ordenadas) que se redimensionan
automáticamente al agregar nuevos elementos, por lo que se le
pueden agregar "teóricamente", infinitos elementos. Los
vectores nos permiten acceder a cualquier elemento que
contenga, mediante el operador[]. Debe tenerse en cuenta que si
se intenta acceder a una posición que excede los límites del
vector, este no hará ningún chequeo, por lo que se debe ser
cuidadoso al utilizar este operador. Para asegurar un acceso
seguro al vector, se puede utilizar el método at(int), que lanza
una excepción de tipo std::out_of_range en caso de que esto
ocurra.
Para añadir elementos al final del vector, se utiliza el método
push_back(const T&). Por otro lado, para eliminar un elemento
del final del vector, se debe usar el método pop_back().

#include <vector> //librería que contiene a la clase vector
#include <iostream>
int main() {
vector<int> intVector; //crea un vector de enteros (sin elementos)
intVector.push_back(25); //agrega el entero 25 al vector
cout << "El primer elemento es: " << intVector.front() <<
" y mi vector tiene " << intVector.size() << " elementos." << endl; //imprime el primer
elemento, retornado por el método front()
intVector.push_back(32); //agrego el entero 32 al vector
cout << "El primer elemento es: " << intVector[0] << endl; //imprime 25
intVector.pop_back(); //elimina el último elemento del vector (i. e. 32)
cout << "Ahora tengo: " << intVector.size() << " elementos." << endl; //imprimirá 1
return 0;
}

Colas dobles: son parecidas a los vectores, pero tienen mejor eficiencia para agregar o
eliminar elementos en las "puntas".
deque<tipo_de_dato> nombre_de_la_cola;
Además de los métodos push_back(const T&) y pop_back(), se agregan los métodos
push_front(const T&) y pop_front(), que realizan lo mismo que los ya explicados, pero en el
comienzo de la cola.
#include <deque> //librería de deques
int main() {
deque<int> intDeque;
intDeque.push_front(25);
intDeque.push_back(12);
while(intDeque.size())
intDeque.pop_back(); //borra todos los elementos
return 0;
}

Listas: Son eficientes a la hora de agregar elementos. La
diferencia con las colas dobles, es que son más eficientes para
eliminar elementos que no estén en alguna de las "puntas"
list<tipo_de_dato> nombre_de_la_lista;
Adaptadores de secuencia.
Contenedores asociativos: map y multimap, que permiten asociar
una "clave" con un "valor". map no permite valores repetidos,
mientras que multimap si.
map<tipo_de_llave, tipo_de_dato> nombre_del_map;
multimap<tipo_de_llave, tipo_de_dato> nombre_del_multimap;

#include <map> //librería que contiene a map y multimap
#include <string> //librería de strings
#include <iostream> //librería de entrada/salida
int main() {
map<int, string> intAString;
intAString[1] = "uno";
intAString[10] = "diez";
cout << "En intAString[1]: " << intAString[1] << endl;
cout << "En intAString[10]: " << intAString[10] << endl;
return 0;
}

ITERADORES
Pueden considerarse como una generalización de la clase de
"puntero". Un iterador es un tipo de dato que permite el
recorrido y la búsqueda de elementos en los contenedores. Como
las estructuras de datos (contenedores) son clases genéricas, y
los operadores (algoritmos) que deben operar sobre ellas son
también genéricos (funciones genéricas), Stepanov y sus
colaboradores tuvieron que desarrollar el concepto de iterador
como elemento o nexo de conexión entre ambos. El nuevo
concepto resulta ser una especie de punteros que señalan a los
diversos miembros del contenedor (punteros genéricos que como
tales no existen en el lenguaje).

ALGORITMOS
Combinando la utilización de templates y un estilo específico
para denotar tipos y variables, la STL ofrece una serie de
funciones que representan operaciones comunes, y cuyo objetivo
es "parametrizar" las operaciones en que estas funciones se ven
involucradas de modo que su lectura, comprensión y
mantenimiento, sean más fáciles de realizar.
Un ejemplo es la función copy, la cual simplemente copia
variables desde un lugar a otro. Más estrictamente, copia los
contenidos cuyas ubicaciones están delimitadas por dos
iteradores, al espacio indicado por un tercer iterador.

La sintaxis es:
copy (inicio_origen, fin_origen, inicio_destino);
De este modo, todos los datos que están entre inicio_origen y
fin_origen, excluyendo el dato ubicado en este último, son
copiados a un lugar descrito o apuntado por inicio_destino.
Un algoritmo muy importante que viene implementado en la
biblioteca STL, es el sort. El algoritmo sort, ordena cualquier
tipo de contenedor, siempre y cuando se le pasen como
argumentos, desde donde y hasta donde se quiere ordenarlo.

#include <vector>
#include <deque>
#include <algorithm>
int main() {
vector<int> intVector;
intVector.push_back(60);
intVector.push_back(12);
intVector.push_back(54); //para este momento, el vector tiene
60,12,54
sort(intVector.begin(), intVector.end()); //listo, array ordenado,
ahora tiene 12,54,60
/*Notar que si en vez de un vector, fuese una deque, se ordenaría de
la misma manera. */
}

Entre las funciones más conocidas están swap (variable1,
variable2), que simplemente intercambia los valores de variable1
y variable2; max (variable1, variable2) y su símil min (variable1,
variable2), que retornan el máximo o mínimo entre dos valores;
find (inicio, fin, valor) que busca valor en el espacio de variables
entre inicio y fin; etcétera.
Los algoritmos son muy variados, algunos incluso tienen versiones
específicas para operar con ciertos iteradores o contenedores, y
proveen un nivel de abstracción extra que permite obtener un
código más "limpio", que "describe" lo que se está haciendo, en
vez de hacerlo paso a paso explícitamente.

APLICACIONES
El programa o aplicacion que recibe los datos de la forma es el siguiente:
#using <mscorlib.dll>
#using <System.dll>
#using <lcnet.dll>
using namespace System;
void main(){
//declarando variables
int base1, altura;
Double area;

REQUISITOS
PROGRAMACIÓN
INTERNET (POI)
Para poder construir programas o aplicaciones orientadas a internet en VISUAL CPP CGI, se ocupa lo siguiente:
1.- Una pc con enlace directo a internet esta pc le llamaremos servidor fisico
2.- El mejor editor del mundo, para crear paginas html y programas de vcpp, el NOTEPAD o WORDPAD de windows.
3.- El compilador de VISUAL CPP, que se puede obtener gratis, bajandolo de www.microsoft.com/net/, aguas son mas de 100
mb, bajarlo e instalarlo con todos los default's o comprar el visual studio net o mejor aun vc++ net
4.- Una libreria especializada en obtener los datos que manda una pagina html, llamada lcnet.dll que se puede bajar aqui
www.programacionfacil.com/visualc++/lcnet.dll bajarla y ponerla dentro de el folder (TAREAS) o directorio donde crearan
todos los programas que se pediran en este curso.

CONDICIONES SIMPLES
Variables Operadores Relacionales Constante o Variables
sexo = m
sueldo > 300,000
En general todas las condiciones se forman con;

CONDICIONES
COMPUESTAS
En muchas ocasiones es necesario presentar mas de una
condición para su evaluación al computador.
Por ejemplo que el computador muestre la boleta de un
alumno si este estudia la carrera de medicina y su promedio de
calificaciones es mayor de 70.
En muchas ocasiones es necesario presentar mas de una condicion para su evaluacion al computador.
Por ejemplo que el computador muestre la boleta de un alumno si este estudia la carrera de medicina y su promedio de
calificaciones es mayor de 70.

Tutorial jared

Más contenido relacionado

La actualidad más candente (20)

Similar a Tutorial jared (20)

Más de HUGOJAREDSANCHEZMARTINEZ (20)

Último (20)

Tutorial jared