Mensajes

sip el mejor es este y no ningun otro

........................

.........................

voto igual !

no importa el metodo que utilizes lo que importa es que funcione

eso incluye los troyanos ? xd 

exelente curso lo voy a leerla. gracias

[Curso de Perl desde 0]

   

Curso de Perl desde 0
by Vengador de las Sombras  

________________________________________
Curso de Perl desde 0
Por Vengador de las Sombras

  Saludos!

  Incio este curso de perl desde cero con el objetivo de adentrar a la gente en el maravilloso mundo de PERL, un lenguaje extremadamente sencillo, versátil y al que se le puede sacar mucho jugo. Antes que nada hacer una pequeña introducción al curso, diciendo que las extensiones de los archivos con los que vamos a trabajar tienen como extensión .pl . Para poder comenzar el curso, necesitaremos de un intérprete de PERL. En mi caso, os recomiendo utilizar ActivePerl, encontrareis manuales a patadas por Google. Para "ejecutar" nuestro .pl deberemos de situarnos en el directorio donde lo tenemos y teclear:

Microsoft Windows XP [Versión 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

V3NG4D0R C0MM4ND3R L1N3:    Perl ARCHIVO.pl

________________________________________


  Todos nuestros programas en perl los iniciaremos con una línea que se usa como standar para identificar que se trata de un source en perl (en realidad en máquinas basadas en Unix se utiliza para indicar el lugar del intérprete, así que en Windows puede sobrar, pero siempre es bueno ponerlo para aclarar). La línea en cuestión es:

Código [Seleccionar] Expandir

#!/usr/bin/perl

  Cuando una línea se inicia con el carácter #, se le indica al intérprete que ignore esa línea. Es usado para introducir comentarios aclaratorios dentro del programa, realizando la misma función que "rem" en batch.

   Bien, lo siguiente que se ve en un lenguaje es cómo imprimir por pantalla líneas de texto. En PERL la función encargada (a la larga veremos otra función más tipo C) es print. Su sintaxis es muy sencilla:

Código [Seleccionar] Expandir

print "Texto";


  Fijémonos en un detalle fundamental, al acabar cualquier funcion/sentencia siempre debemos de poner ; para indicar que finaliza. Existen funciones de escape indicadas con \letra. Nosotrs las iremos estudiando conforme las necesitemos. Por ahora sólo teneis que aprenderos el salto de línea (que es igual que en el resto de lenguajes de programamción), es \n.


  Entonces un programa simple, el típico Jelou Güorld (como diría Seth) sería algo tipo:

Código [Seleccionar] Expandir

#!/usr/bin/perl
print "Jelou";
print "\nGuorld";


  Cuando se desea imprimir varias líneas de texto se recurre a print q( TODO EL TEXTO);. Cuando se imprime así, no es necesario recurrir a los caracteres de escape, ya que en el output (lo que sale por pantalla) aparece tal y como lo escribamos. Para que se entienda mejor, aquí dejo la cabecera de un programa que codee la otra noche:

Código [Seleccionar] Expandir

print q(
=====================================================
            HTTP HEADER F.o.S. Injector v0.0
    Priv8 Edition-Cod3x by Vengador de las Sombras
                          &
               Mace Windu & Chipbios
Gr3tz to: WaesWaes, Plaga, Lutscher, Harakiri, Phonix
=====================================================
);
Si lo probais, veis como aparece el texto centrado y apareciendo los diferentes saltos de líneas
Las variables....


  Si bien voy a intentar apotar a este curso desde cero todo lo que sé sobre variables, cómo usarlas, etc... no lo voy a hacer a saco, puesto que como he dicho este es un curso desde "0" enfocado a NW's en la materia. Es por ello que si voy a saco hablando de variables locales y globales (hablando de variables de ambiente), hashes, arrays y demás seguro que me matais XD  :6:.  Así que a lo largo del curso iremos aumentando progresivament e la dificultad del contenido XD, es decir, que empezemos por lo básico  .


  Parto de la base de que como mínimo la gente que está leyendo este tutorial ya habrá visto pseudolenguaje s tipo "Batch", y estará familarizado con qué es una variable, así que sin más problemas nos metemos a hablar de ellas  .

  Las variables en PERL vienen señalizadas con el carácter $ (Como en casi todos los lenguajes, vamos XD). Pueden contener desde strings (Cadenas de caracteres) hasta números con los que operar (las llamadas variables escalares). La ventaja de PERL es que el manejo de variables, en mi opinión, es sencillo, ya que te permite colocarlas en casi cualquier parte del source de nuestro programa, sin necesidad de declararlas desde un inicio, como pasa en otros lenguajes.


  La forma más simple de "setear" (a partir de ahora voy a usar ese término para referirme a introducir un valor a una variable) una variable es colocando el mítico $variable = 5;. Una cosa a tener encuenta para evitar posibles errores, es que las variables en PERL son case-sensitives (creo que se decía así), es decir, son sensibles a mayúsculas y minúsculas. Por ende, no será lo mismo $Var que $VAR, ni que $var.


  Las variables pueden ser utilizadas en operaciones aritméticas de forma simple, usando los caracteres encargados de ello. Las operaciones aritméticas (existen aritméticas y lógicas) que se pueden realizar las dejo en el siguiente cuadro:
_________________________
OPERACIÓN  l CARACTER
_________________________
Suma   +   
_________________________
   
Resta   -   
_________________________
   
División   /
_________________________
   
Multiplicación   *
_________________________
   
Potencia   **
_________________________
   
Módulo   %
_________________________
   

Hay más, pero con estos nos apañamos por ahora.


Un ejemplo aclaratorio:
(ejemplo)

Código [Seleccionar] Expandir

#!/usr/bin/perl
# Ejemplo de Aritmética

$var = 1;
$var2 = 3;
$resultado = $var + $var2;
$modulo = $resultado % 2;

print "El resultado de todas las operaciones es:\n\n\n $modulo";

exit(0); # Funcion de finalización

Siendo el output (Salida por consola) esto:
: Output

V3NG4D0R C0MM4ND3R L1N3:    perl a.pl
El resultado de todas las operaciones es:

0

  Alejándonos de la aritmética, pero sin abandonar a nuestras amigas las variables, vamos a ver cómo meter cadenas de texto dentro de una variable. Para realizar esto, simplemente debemos de entrecomillar el String a almacenar en nuestra variable. Es decir, quedaría así:

Código [Seleccionar] Expandir

$texto = "FoS RoolZ!";

Cabe destacar que se puede interpolar una variable dentro de otra cadena de texto (no confundir con concatenar), es decir, si hacemos algo tal que así:

Código [Seleccionar] Expandir

$var = "FoS";

$Todo = "$var TeaM Rocks!";
#$todo valdría FoS TeaM Rocks!


En PERL hay existen dos formas de entrecomillación, la vista hasta el momento, usando "contenido" y otra usando las comillas simples, es decir, 'contenido'. La diferencia entre ambas, es que de la segunda forma toma todo de forma "literal", es decir, usando el anterior ejemplo pero con comillas simples:

Código [Seleccionar] Expandir

$var = "FoS";

$Todo = '$var TeaM Rocks!';
  Si imprimiesemos por pantalla la variable $Todo, el output arrojaría $var TeaM Rocks!.


________________________________________

Bueno, hasta aquí el capítulo de Hoy. Creo que es una buena introducción a las variables, aunque me he dejado en el tintero ciertas cosas, como las variables implícitas $_ , los argumentos y cosas así, pero ya se verán en próximos capítulos.
En el capítulo anterior ya empezemos a trabajar con variables, en este nuevo capítulo vamos a seguir viendo un poco más del tema de las variables.


   Hasta este momento, la única forma de asignación de variables es colocandolo intrínsecamente dentro del código fuente de nuestro programa. Lo que vamos a hacer a continuación es exponer dos modalidades diferentes de introducir valores en variables, el primero a través del teclado y la segunda a través de "argumentos" que se introducen de forma externa.


   Para introducir un valor a través del teclado se utiliza la expresión <STDIN>. No existe ningún misterio de como hacerlo, puesto que únicamente hay que poner <STDIN> como valor de la variable que deseamos rellenar a través del teclado. O sea, que quedaría algo tipo:

$variable=<STDIN>;


  Como habeis observado, la simplicidad del método implica que no tengamos que expandirnos mucho en la explicación de este tema... Así que simplemente deciros que antes de la asignación de la variable, recomiendo poner un print que indique qué contenido debe de tener la variable:

Código [Seleccionar] Expandir

print "[?] Edad:\n";
$edad=<STDIN>;
print "[+] Tu edad es $edad"


  Captado el concepto, pasamos a algo más interesante: los argumentos. Los argumentos son variables las cuales tienen todas la misma composición: $ARGV[X]. Donde "x" es un número natural (entero positivo).

  Las variables argumentales ("Argumentos") se pasan al programa a través de la shell, de la siguiente forma:

Perl programa.pl [Argumento 0] [Arguemento 1] .... [Argumento X]

Cada una de las palabras que se expresan a continuación (y separadas por espacios) del programa son los valores que tomarán las diferentes variables. Las variables se expresan con $ARGV[], colocando entre corchetes el número de argumento (el primer argumento es el 0). Entonces, podemos visualizar el siguiente ejemplo:

Código [Seleccionar] Expandir

#!/usr/bin/perl
print "Te llamas $ARGV[0] , tienes $ARGV[1] años";
exit(0)

Si invocamos este programa desde línea de comandos:

Microsoft Windows XP [Versión 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

Fl4mm1ng 0ur Sk1llZ:    perl ejemplo.pl Vengador 16

Las variables asignarán la palabra(0) (vengador) a la variable $ARGV[0], y con el otro argumento igual.

Existe una variable, la cual indica el número de argumentos que hemos introducido, ésta @ARGV. Lógicamente sólo expresará valores enteros positivos.
Continuemos...

  Vamos a dejar por un tiempo las variables, para entrar en otros temas, pero no nos olvidamos definitivament e de ellas, puesto que ampliaremos más adelante. Hago esto para no agobiaros todo el rato con el mismo tema  newrussian .

  Entonces, lo que tenía pensado hacer hoy es introduciros en las funciones de control de flujo. Estas funciones se encargan de ejecutar un grupo de sentencias cuando se alcanza cierta condición. Las condiciones pueden contener operadores lógicos, como ya veremos más adelante. Algunas de estas funciones son IF (con Elseif en anidamientos, y Else), While, Do-Until, Unless, For y cosas por el estilo. Empezaremos estos días a ver los más simples.


  Para empezar, os explicaré qué es un bucle o loop. Son conjuntos de sentencias que se ejecutan un número de veces definido por una condición, y esta condición es procesada por una sentencia de control de flujo. Existen dos tipos principales de bucles, los finitos y los infinitos.

  Los finitos son aquellos grupos de sentencias que se repiten de forma reiterativa hasta que una condición se vuelve TRUE o FALSE, según se haya definido. Por contraposición, los bucles infinitos son aquellos que se repiten sin parar.


  El primer tipo de sentencia para realizar bucles es Do. La sintaxis de Do es muy sencilla:

DO {
.............. ....
.............. ..
.............. ..
(Sentencias)
.............. .......
.............. ..........
} until (condición);

  Traducido al castellano, el código vendría a significar:

"Hacer estas sentencias hasta que pase esto".

Ahora quiero comentaros un tipo de operación aritmética que antes no comenté, los incrementos y decrecimientos . Esta operación aritmética consiste en aumentar o disminuir 1 a 1 una variable que contiene un valor entero. Se expresan de la siguiente forma:

$variable++    Para sumarle 1
$variable--     Para restarle 1

Os explico esto, para proponeros el primer ejemplo sencillito de bucle Do-Until:

Código [Seleccionar] Expandir

#!/usr/bin/perl
$variable = 0;

do
{
           $variable++
           print "\nLa variable vale $variable";
} until ($variable eq "15");
exit(0);
           

Eq significa "igual a". tambien se puede expresar como ==. Cuando tenga un ratejo continúo con el manual y completo con todos los operadores lógicos y explico cada uno, a parte veremos la primera parte de if (ya que if tiene muuuuuuucha tela que contar, aunque parezca que no.).

Tras un breve periodo sin conexión a internet por problemas ajenos a mí (pvtas líneas y pvta timofónica) podemos seguir con el curso...


  Creo recordar que lo dejemos cuando empecemos a ver las estructuras de control... Hoy vamos a centrar nuestra atención en las estructuras condicionales, usando IF, ELSE, ELSIF y UNLESS.


  El tipo más simple de condición se desarrolla utilizando la sentencia IF, cuyo uso más simplificado es if (condiciones) { Grupo de Sentencias } . Dentro de las condiciones que han de darse para que se ejecute el grupo de sentencias delimitadas por { y }, podemos encontrar dos tipos. Por un lado las condiciones basadas en variables numéricas estrictas, y cuyas operaciones lógicas permitidas son:

==     igual que...
!=      distinto de...
<       menor que...
>      mayor que...
>=     mayor o igual que...
<=     menor o igual que...


Al mismo tiempo, estas condiciones se complementan con otras a través de otras operaciones lógicas, como pueden ser and (&&) y or (||). La operación AND sirve para que dos o más condiciones se tengan que dar, en cambio, la operación lógica OR, implica que si no se cumple una condicion, pero se cumple otra, se puedan ejecutar el grupo de sentencias.  Un ejemplo para asimilar esto, pudiera ser:

Código [Seleccionar] Expandir

$variable=<STDIN>;
if ($variable > 15 && $variable < 30) {
print "El número está entre 15 y 30";
}
exit(0)

El otro tipo de condiciones son aquellas cuyas variables no son estrictamente numéricas, sino que pueden estar compuestas por grupos de caracteres alfanuméricos. Para este caso, los operadores a utilizar son:

Código [Seleccionar] Expandir

    - eq   igual que...
    - ne   distinto de...
    - lt     menor que...
    - gt    mayor que...
    - ge   mayor o igual que...
    - le    menor o igual que...


En este caso, con lo que se compare se deberá de poner entrecomillado . Hasta ahora hemos visto cuando la condición que se cumple es "verdadera", pero ¿Y si la condición "no se cumple"?. Para esto disponemos del condicional unless, cuya sintaxis es idéntica al del IF.

  Con IF  podemos tambien comprobar si una variable está definida (o como yo suelo decir "seteada"), para ello el código sería if ($variable){ SENTENCIAS} . Igualmente encontramos el caso contrario, si no está definida una variable debemos de añadir un ! delante de la variable, quedándonos algo tipo: if (!$variable){ grupo de sentencias }. Esto último tambien podemos realizarlo con UNLESS: unless ($variable){ Sentencias}

Sigamos con IF....


Si usasemos únicamente IF como condicional, el programa que generásemos sería demasiado estricto y probablemente contendría bastantes bugs y código basura que aumentarían en bastante el peso. Esto sería debido a que únicamente podemos concretar una condición por cada IF, pero... ¿Y si necesitamos que el flujo se bifurque cuando no se cumpla la condición?.

Para este caso podemos montar otra estructura de control basada en IF y ELSE. Else va a ser como "Si no se cumple esta condicíón, haz este grupo de sentencias". En cuanto a su sintaxis, es de suma sencillez, veámosla con un ejemplo:

Código [Seleccionar] Expandir

print "Introduzca su edad";
$edad=<STDIN>;
if ($edad >= 18){
                          print "\nEres Mayor de Edad";
else {
print "\NEres Menor de Edad";
}


Dentro de un IF pueden encontrarse múchos más IF y ELSES.

Bien... pero... y si necesitamos bifurcar un flujo ante tres condiciones diferentes ? Para esta función existen los llamados "anidamientos". Son estructuras que consisten en usar un paso intermedio entre IF y ELSE: elsif. Elsif viene a ser como "Haz esto si la condición de arriba es False y esta es True". Podemos poner tantos elseif como queramos dentro del código fuente:

Código [Seleccionar] Expandir

if (Condicion){
Setnencias
}
elseif (Condicion){
Sentencias
}
elseif (Condicion){
Sentencias
}
else {
Sentencias
}

De IF todavía quedan cosas que contar, pero lo vamos a dejar aparcado para el próximo día hablar sobre otras estructuras de control

Bueno... sigamos por donde lo dejemos....


El último día dije que ibamos a ver alguna otra estructura de control, y eso es lo que haremos. Hoy le toca a while.

While se utiliza para formar estructuras muy simples, cuyo funcionamiento es que se ejecute un grupo de sentencias mientras (while) una condición determinada sea TRUE. Entonces la cosa sería algo tipo:

Código [Seleccionar] Expandir

while (condicion) {
sentencias a ejecutar
}

Cuando la condición de while se vuelva FALSE, el bucle finalizará y dará paso a las siguientes sentencias que haya por debajo de éste.

Un sencillísmo ejemplo sería:

Código [Seleccionar] Expandir

while ($variable < 5){
$variable++;
print "\n$variable";
}

Normalmente while yo lo suelo usar mucho cuando trabajo con sockets. Bueno, otro bucle que es muy usado en PERL (Y en casi todos los lenguajes) es FOR.

La estructura de for es muy simple, for(valor_incial,Valor_final,cambios){ stnencias}

Es muy simple, con un ejemplo se ve claro:

Código [Seleccionar] Expandir

for ($var=1,$var<=5,$var++){
print "$var\n";
}

¿Simple no? La variable $var va a tomar valor "1", y va a ir aumentando de uno en uno mientras que sea inferior o igual a 5. Una cosa que no se suelen explicar en los manuales, es el uso de next  y last dentro de estas estructuras repititivas.

  Usando IF y NEXT podemos hacer que cuando $var cumpla X condición, no se ejecute el grupo de sentencias, y con if y last, lo que podemos hacer es que se ejecuten las sentencias hasta que se cumpla X condición. Un ejemplo sería:

Código [Seleccionar] Expandir

for ($var=1,$var<=5,$var++){
if ($var == 2){
  next;
}
print "$var\n";
}

Y este otro:

Código [Seleccionar] Expandir

for ($var=1,$var<=5,$var++){
if ($var == 2){
  last;
}
print "$var\n";
}


Bueno... hasta aquí la parte de hoy... el próximo día empezaremos a ver el manejo de archivos... byt3z...

Para lo que el manejor de archivos, vamos a necesitar de la sentencia open(), la cual usaremos de la siguiente forma:

open(LOGICO,"indiFISICO);

Lógico hace referencia al soporte lógico que se forma con el archivo, es decir, cada vez que realicemos una operación a LOGICO, se la estaremos haciendo al fichero (que de no existir, lo crearemos). En indi se coloca < si lo que queremos es leer el archivo FISICO, > si queremos crear el archivo FISICO. En caso de usar >, si el fichero FISICO existe, se sobre escribe en él con el último puntero. Despues nos encontramos >> que escribe en el archivo FISICO pero dejando el puntero debajo de lo que ya existía, con lo que no sobreescribimo s el archivo.

  Y por último FISICO es el archivo, por ejemplo archivo.txt, index.htm, virus.bat, etc.


Bien ahora ya sabemos como hacer referencia a los archivos, en las distintas formas que vamos a necesitar (lectura y escritura).

Ahora, cuando queramos realizar operaciones con nuestro fichero abierto, tendremos que hacerlos sobre lo que hemos denominado LOGICO. Esta debe de ser una palabra escrita en mayúscula. Cuando terminemos de realizar las operaciones sobre nuestro fichero debemos de cerrarlo, para ello tendremos que usar la función inversa: close(). Tenemos que poner dentro de () el nombre lógico del archivo que estamos manejando, ergo close(LOGICO);.


Pero todo esto está muy bien... Pero... ¿Cómo puedo operar dentro de un fichero?

Sencillo, si abrimos un archivo en modo Lectura, lo único que podremos hacer es leer las lineas que contiene. Para realizar esto podemos valernos de un bucle foreach :

Código [Seleccionar] Expandir

#!/usr/bin/perl
open(FILE,"<archivo.txt");
@source = <FILE>;
foreach $linea (@source){
print $linea;
}
close(FILE);

Con @source lo que hacemos es volcar el contenido de archivo.txt dentro de este arreglo (ya veremos en otra ocasión que es esto). Despues vamos linea por linea viendo el contenido de archivo.txt, y cada linea queda guardada en $linea y es imprimida por pantalla.


  Este sería un ejemplo muy sencillo para poder leer un fichero. Para escribir dentro de un archivo, sólo tenemos que hacer print al soporte lógico:

Código [Seleccionar] Expandir

#!/usr/bin/perl
open(FILE,">archivo.txt");
while ($contador >= 5){
$contador++;
print FILE "Nuestra linea numero $contador\n";
}
close(FILE);
exit(1);

Bueno me sirvió de mucho este curso. aunque no llegó a su final.. cuando sea completado lo postearé..
portalhacker(.net)

Proximo día sockets "light" (sin complicaciones, que ya habrá tiempo de usar sockets al estilo "complejo").

[Parte 1 del Curso de VideoTutoriales de C++.]

Bueno quise aportar un poco mas  ya que aquí encontré unos tantos
videos más :

Parte 1 del Curso de VideoTutoriales de C++.

Contenido:

Programación Orientada a Objetos.
Una breve historia de C++;
Evolución de C++;
¿Debo aprender C primero?;
C++, Java y C#;
Managed Extension de Microsoft para C++;
El Estándar ANSI;
El entorno de desarrollo;
El Proceso de creación de un Programa;
Primer Programa C++;
Trabajar con el Compilador.
Son 50 minutos en 35 megas.

Descargar:
http://rapidshare.com/files/83815729/cpp001_by_Shevchenko.zip

Parte 2 del Curso de VideoTutoriales C++.

Contenido:

Análisis de un Programa C++.
Las partes de un Programa.
Uso del Objeto Cout;
Usar el Estándar Namespace;
Incluir Comentarios en tus Programas;
Funciones;
Partes de una Función;
Ejemplos prácticos.
Son 50 minutos en 32 megas.

Descarga:
http://rapidshare.com/files/83828801/cpp002_by_Shevchenko.zip

Parte 3 del Curso de VideoTutoriales C++.

Contenido:

Empezamos con los Fundamentales.
Trabajo con Variables: ¿Qué es una variable?; Definir una Variable; Crear Varias variables a la vez;
Asignar valores a las Variables;
Crear Aliases con typedef;
El tipo int;
Uso de short y long;
Trabajar con Caracteres. 47 minutos en 25 megas.

Descargar
http://rapidshare.com/files/84586339/cpp003_by_Shevchenko.zip

Parte 4 del Curso de VideoTutoriales C++.

Curso de C++ VT Nº 4 del Curso de VideoTutoriales C++.

Seguimos viendo como tratar con datos y dedicamos este VideoTutorial a las Constantes.

Uso de Constantes;
Constantes Literales y Constantes Simbólicas;
Definiar constantes con #define;
Definir constantes con const;
Sintaxis y uso de Constantes enumeradas;
Ejemplos Prácticos. Terminamos con un cuestionario y una práctica sobre los temas vistos.

Son 21 minutos en 14 megas.

Descargar
http://rapidshare.com/files/85449432/cpp004_by_Shevchenko.rar

Parte 5 del Curso de VideoTutoriales C++.

Contenido:

Crear Expresiones y Declaraciones.
Crear declaraciones;
Usar espacios en blanco;
Bloques y declaraciones compuestas;
Expresiones;
Trabajar con Operadores;
Operadores de Asignación;
Operadores Matemáticos;
Operador de División y Modulus;
Combinar Operadores matemáticos y Operadores de asignación;
Incrementación y Decrementación;
Prefijo y Postfijo;
Entender la prioridad de los Operadores;
Uso de paréntesis y paréntesis anidados.
53 minutos en 30 megas.

Descargar
http://rapidshare.com/files/85457389/cpp005_by_Shevchenko.rar

Trabajar con Condicionales
VideoTutorial Nº 6 Del Curso de Programación en C++.

Empezamos a ver como tomar decisiones mediante el uso de Condicionales y Operadores Relacionales.
Código dinámico;
Evaluar con Operadores Relacionales;
La Declaración if;
La Declaración Else;
Declaraciones if Anidadas;
Uso de llaves en las declaraciones if anidadas.
Algo más de 50 minutos en 24 megas.
Incluye los archivos de ejemplo.

Descargar
http://rapidshare.com/files/85466046/cpp006_by_Shevchenko.rar

Video Tutorial Nº 7 del Curso de C++.

Operadores Lógicos.
El Operador Lógico AND;
El Operador Lógico OR;
El Operador Lógico NOT;
El Círcuito de Evaluación corto;
Prioridades en el uso de Operadores Relacionales y Lógicos;
Evaluar expresiones según su verdad o falsedad;
El Operador Condicional Ternario;
Ejemplos prácticos.
Son 40 minutos en 21 megas.

Descargar
http://rapidshare.com/files/85474604/cpp007_by_Shevchenko.rar

Organizar con Funciones

VT Nº 8 del Curso de VideoTutoriales Aprende a programar en C++ Empezamos

un bloque dedicado a las funciones.
Que es una función y cuales son sus parte;
Como declarar y definir funciones;
Valores de retorno, Parámetros y Argumentos;
Como pasar valores a funciones;
Como devolver valores desde funciones.
30 minutos en 22 megas.

Descargar
http://rapidshare.com/files/85479994/cpp008_by_Shevchenko.rar

VideoTutorial Número 9 del Curso aprende a programar en C++.

Variables locales y globales:
Ejecución de funciones;
Determinar el alcance de las variables;
Variables locales;
Uso de Variables locales y parámetros;
Variables locales dentro de bloques;
Parámetros como variables locales;
Trabajo con variables locales y globales.
Son 40 minutos en 23 Megas.

Descarga
http://rapidshare.com/files/85485707/cpp009_by_Shevchenko.rar

VideoTutorial Número 10 del Curso aprende a programar en C++.

Polimorfismo Funcional.
Crear Declaraciones;
Tipos de Argumentos que se pueden pasar a una función;
Tipos de Valores de Retorno;
Uso de Parámetros por defecto;
Sobrecarga de Funciones;
Polimorfismo funcional.
45 minutos en 32 megas.

Descargar
http://rapidshare.com/files/85496234/cpp010_by_Shevchenko.rar

VideoTutorial Número 11 del Curso aprende a programar en C++.

Funciones Especiales. Funciones Inline;
Recursión;
Síntesis Tema Funciones;
Taller de Trabajo;
Cuestionario;
Ejercicios Prácticos.
55 minutos en 30 megas.

Descargar
http://rapidshare.com/files/85504490/cpp011_by_Shevchenko.rar

Entender Programación Orientada a Objetos
VT Nº 12 Curso C++. Entender Programación Orientada a Objetos.

Introducción a Clases y Miembros;
Declarar una Clase; Definir un Objeto;
Clases Versus Objetos;
Acceder a Miembros de la Clase;
Asignar a Objetos, no a Clases;
Acceso Privado y Acceso Público a Clases;
Hacer las variables Miembro privadas.
46 Minutos en 24 megas.

Descarga
http://rapidshare.com/files/104613457/cpp012_by_Shevchenko.rar

VT Nº 13 del Curso de VideoTutoriales de C++.

Métodos de Clase.
Constructores y Destructores.
Seguimos con la Programación Orientada a Objetos.
Hacer los Datos Miembro privados;
Implementar Métodos de Clase;
Añadir Constructores y Destructores;
Usar el Constructor por Defecto,
Creación de Métodos Constructor y Destructor.
Una hora en 34 Megas.

Descarga
http://rapidshare.com/files/104052347/cpp013_by_Shevchenko.rar

VT Nº 14 del Curso de VideoTutoriales de C++.

Interface Frente a Implementación:
Incluir Funciones Miembro const;
Declaración de Clase o Interface y Definición de Métodos o Implementación;
Colocar las declaraciones de Clase y las definiciones de Métodos en distintos archivos;
Implementaciones Inline.
42 Minutos en 25 Megas.

Descarga
http://rapidshare.com/files/104056216/cpp014_by_Shevchenko.rar

Prácticas con Clases
VideoTutorial número 15 del Curso de C++

En el que terminamos el bloque dedicado a la Introducción a la Programación Orientada a Objetos.
Clases con otras Clases como Datos miembro;
El uso de estructuras;
Resumen fundamentales trabajo con Clases.
Trabajos prácticos. 50 minutos en 32 megas.

Descarga
http://rapidshare.com/files/104557347/cpp015_by_Shevchenko.rar

VideoTutorial Número 16 del Curso de C++.

Trabajo con Loops.
Las raíces del Loop: goto;
Usar Loops While;
Declaraciones While complejas;
Uso de continue y break;
Uso del while (true).
Son 40 minutos en 23 megas.

Descarga
http://rapidshare.com/files/104301290/cpp016_by_Shevchenko.rar

VideoTutorial número 17 del Curso de C++.

Loops do....while, for y switch:
Usar el loop do..while;
Hacer loop con la declaración for;
Loops for avanzados;
Múltiples declaraciones en un loop for;
Declaraciones Null en los Loops for;
Loop for vacío;
Loops anidados;
Resumir loops;
Controlar el flujo con las declaraciones switch;
Usar una declaración switch con un menú.
Una hora en 34 megas.

Descargar
http://rapidshare.com/files/104297599/cpp017_by_Shevchenko.rar

VT 18 del Curso de VideoTutoriales de C++.

Crear Primer Programa Completo.

Terminamos el primer Bloque del Curso con la creación de un programa que nos sirva para repasar todos los temas fundamentales que deben estar claros antes de pasar al siguiente Bloque del Curso.

A medida que vamos elaborando el programa indicamos los VideoTutoriales donde se han ido tratando las distintas partes del mismo.

Son 25 minutos para saber si estás preparado para pasar a la siguiente fase del curso.

Descarga
http://rapidshare.com/files/104644257/cpp018_by_Shevchenko.rar

VT Nº 19 del Curso de C++.

Entender los Punteros.
¿Qué es un Puntero?;
Entender como C++ utiliza la memoria;
Obtener la dirección de memoria de una variable;
Almacenar la dirección de una variable en un Puntero;
Obtener el valor de una variable de modo indirecto;
Dereferenciando con el Operador Indirecto;
Punteros, Direcciones y Variables;
Manipular datos usando punteros;
Saber lo que está almacenado en los punteros;

50 Minutos en 28 Megas.

Descarga
http://rapidshare.com/files/104561603/cpp019_by_Shevchenko.rar

VT nº 20 del Curso de C++ en el que seguimos profundizando en los Punteros.

Como utilizan los punteros la memoria.
¿Por qué debemos usar Punteros?;
Las áreas de memoria que usa C++;
El Stack y el Free Store (Heap);
Fugas de Memoria;
Crear Objetos en el Free Store;
Borrar Objetos del Free Store;
Acceder a Datos Miembro;
Crear Datos Miembro en el Free Store.

Algo más de una hora en 39 Megas.

Descarga:
http://rapidshare.com/files/104567858/cpp020_by_Shevchenko.rar

VideoTutorial número 21 del Curso de C++.

Punteros This y Punteros Constantes.
Punteros this; Punteros Salvajes o extraviados;
Usar Punteros Constantes;
Resumen Punteros;
Apartado práctico trabajo con punteros.
Son 45 minutos en 37 megas.

Descarga
http://rapidshare.com/files/104581679/cpp021_by_Shevchenko.rar

VideoTutorial Número 22 del Curso de C++.

Trabajar con Referencias.
¿Qué es una Referencias?
Crear y utilizar Referencias;
Usar el Operador Address-Of (&amp en Referencias;
Las Referencias no pueden reasignarse;
Referenciar Objetos;
Pasar Argumentos a Funciones por Referencia con Punteros y pasar Argumentos a Funciones por Referencia con Referencias.
48 Minutos en 32 Megas.

Descargar
http://rapidshare.com/files/104589096/cpp022_by_Shevchenko.rar

VideoTutorial Nº 23 del Curso de C++.

Seguimos viendo Punteros y Referencias:
Devolver múltiples valores desde una función;
Devolver múltiples valores con punteros;
Devolver múltiples valores por referencia;
Pasar por Referencia es más eficiente;
Pasar objetos por Referencia;
Pasar punteros a u objeto Constante;
Pasar Referencias a Objetos;
Saber cuando usar Referencias y cuando usar Punteros.
Unos 50 Minutos en 53 Megas.

Descargar
http://rapidshare.com/files/104575847/cpp023_by_Shevchenko.rar

VideoTutorial Número 24 del Curso de C++.

Empezamos con el bloque dedicado a Análisis y Diseño Orientada a Objetos.

Una primera introducción de 30 minutos en que vemos una perspectiva general del tema.
Construir Modelos;
Diseño de Software: El lenguaje de Modelado;
Diseño de Software: El Proceso;
Desarrollo en Espiral y Desarrollo en Cascada;
Fases del Proceso de Desarrollo en Espiral.

VideoTutorial con muchos gráficos y esquemas.
He decidido no meter ningún tipo de comprensión en la imagen y grabar con la calidad de sonido más alta.

Aumenta el tamaño pero creo que es necesario.

Son 30 minutos y ocupa 50 Megas.

Descargar
http://rapidshare.com/files/122185530/cpp024_by_Shevchenko.rar.html

VideoTutorial Nº 25 del Curso de C++.

Seguimos con el Bloque dedicado al Análisis y Diseño Orientado a Objetos.

Fases de Conceptualización y Análisis.

Empezar con la Visión;
Reunir los Requerimientos;
Casos de Uso;
Identificar a los Actores;
Determinar los primeros casos de uso;
Crear el Modelo de Dominio;
Uso de la Plataforma de Desarrollo de Software Rational de IBM.

Son 42 Minutos y 59 Megas.

Descarga
http://rapidshare.com/files/122207992/cpp025_by_Shevchenko.rar.html

Escenarios, Visualizaciones y Artefactos.

VideoTutorial Nº 26 del Curso de C++ en el que seguimos con Análisis y Diseño Orientado a Objetos.

Vemos dentro de la fase de Análisis del Desarrollo del Proyecto como establecer Escenarios y Líneas Guía;
Como crear un Diagrama de Caso de Uso;
Los Estereotipos; Diagramas de Interacción;
Creación de Paquetes;
Analisis de Sistema y de Aplicación;
Documentos de Planificación;
Visualizaciones y Artefactos.

Terminamos con esto la fase de Análisis del Proyecto.

Son 25 minutos en unos 26 Megas.

Descarga
http://rapidshare.com/files/104595517/cpp026_by_Shevchenko.rar

Análisis y Diseño Orientado a Objetos: Fase de Diseño

VideoTutorial Número 27 del Curso de C++.

Seguimos con el Análisis y Diseño Orientado a objetos y dedicamos este videotutorial a ver la Fase de Diseño:
¿Qué son las Clases?;
Clases Preliminares;
Transformaciones;
Construir un primer modelo estático;
Usar Tarjetas CRC;
Como conducir una sesión CRC;
Centrarse en las responsabilidades;
Representar el escenario;
Limitaciones de las Tarjetas CRC;
Transformar Tarjetas CRC a UML.

38 minutos en 23 megas.

Descargar
http://rapidshare.com/files/104599404/cpp027_by_Shevchenko.rar

VideoTutorial Nº 28 del Curso de C++.

Modelado con UML.
Transformar las tarjetas CRC a UML;
Relaciones entre Clases: Generalización, Asociación, Agregación y Composición;
Múltiples herencias y Contención;
Discriminadores;
Modelo Dinámico;
Diagramas de Secuencia y de Colaboración;
Diagramas de Transición de Estado;
Super Estados.
Algo menos de media hora en 16 Megas.

Descargar
http://rapidshare.com/files/104609437/cpp028_by_Shevchenko.rar

VideoTutorial Nº 29 del Curso de C++.

Implementar Herencias: Implementar especialización/generalización a través de herencias.
¿Qué son las herencias?;
Herencia y Derivación;
Relaciones entre Clases;
Sintaxis de la Derivación;
Usar un Objeto Derivado;
Herencias con Constructores y Destructores.
Son 26 minutos en 17 Megas.

Descargar
http://rapidshare.com/files/104616968/cpp029_by_Shevchenko.rar

e-r00t.(org)