C# en Visual

INSTITUTO NACIONAL DE MXICO
INSTITUTO TECNOLGICO DE
VERACRUZ
ASIGNATURA:
LENGUAJES UNTOMATAS II
INTEGRANTES:
Gmez Gonzales Citlalli
Morales Hernndez Yazmin Yareli
Palomar Aguirre Jael
Solano Uscanga Maril
CARRERA:
Ing. Sistemas Computacionales.
PROYECTO:
Cdigo Intermedio
DOCENTE:
Martnez Moreno Martha
Veracruz, Ver.
2017.
INIDICE
NDICE 2
DECLARACIN 3
EJEMPLOS EN C# 3
EJEMPLOS EN ENSAMBLADO 4
EJEMPLOS EN JASSM 5
OPERADORES 6
EJEMPLOS EN C# 8
EJEMPLOS EN ENSAMBLADOR 13
EJEMPLOS EN JASSM 18
CICLOS O BUCLES 26
EJEMPLOS EN C# 27
ENTRADA Y SALIDA 33
EJEMPLOS EN C# 34
ESTRUCTURAS 40
EJEMPLOS EN C# 42
BIBIOGRAFA 52
2
DECLARACIN
En programacin, las lneas de cdigo de declaracin son aquellas en donde se escriben las
variables que se usarn y los tipos de datos de cada una.
Por ejemplo:
Int numero1, numero2;
Float numero3;
Esto declara dos variables que contendrn nmeros enteros y una tercera como flotante
.
Ejemplos en C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Suma {
class Program {
static void Main(string[] args) {
//Declaracion de Variables
int num1, num2, suma;

}
}
3
Ejemplos en Ensamblador
Instruccin ADD
Propsito: Adicin de los operandos.
Sintaxis:
ADD destino, fuente
Suma los dos operandos y guarda el resultado en el operando destino.
Debe haber correspondencia entre los tamaos de los registros, es decir:

no se puede sumar a un registro de 16, un registro de 8 y viceversa
ADD AX, BX; AX = 0A11, BX = 00A2
ADD AX,AB; AX = AB3
4
Ejemplos en Jassm
El siguiente cdigo es en Jassm, donde se mostrar cmo en la clase suma, resta,
multiplicacin y divisin se har la declaracin de las variables a utilizar:
.class public suma

.super java/lang/Object
.method public <init>()
aload_0
invokespecial java/lang/Object/<init>()
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma
.method public ()
aload_0
invokespecial java/lang/Object/()
Return
.end method
5
OPERADORES
En C#, un operador es un elemento de programa que se aplica a uno o varios operandos en

una expresin o instruccin. Los operadores que toman un operando, como el operador de
incremento (++) o new, se conocen como operadores unarios. Los operadores que toman
dos operandos, como los operadores aritmticos (+,-,*,/) se conocen como
operadores binarios. Un operador, el operador condicional (?:), toma tres operandos y es el
nico operador ternario de C#.
La instruccin de C# siguiente contiene un solo operador unario y un nico operando. El
operador de incremento, ++, modifica el valor del operando y.
Operadores unarios
Expresin Descripcin
+x Identidad
-x Negacin
!x Negacin lgica
~x Negacin bit a bit
++x Preincremento
--x Predecremento
6
(T)x Convertir x explcitamente en tipo T
Operadores multiplicativos
Expresin Descripcin
* Multiplicacin
/ Divisin
% Resto
Operadores de suma
Expresin Descripcin
x+y Suma, concatenacin de cadenas, combinacin de delegados
x-y Resta, eliminacin de delegados
7
Ejemplos en C#
SUMAS:
Ejercicio bsico de sumar dos nmeros en consola en C#:
using System;
using System.Linq;
using System.Text;
namespace Suma
{
class Program
{
static void Main(string[] args)
{
int num1, num2, suma;
//Explicacion del Ejercicio

Console.Write("\n\tSuma de Dos Numeros");
//Ingresando el primer numero

Console.Write("\nIngrese un numero: ");
num1 = Int32.Parse(Console.ReadLine());

Console.Write("\nIngrese el numero 2: ");
//Realizando la Suma
suma = num1 + num2;
//Mostrando Resultado
Console.WriteLine("El Resultado es: " + suma);
//Detener pantalla
Console.WriteLine("\n\n\tPresione < ENTER > para salir . . .");
Console.ReadKey();
}
}
}
8
RESTAR:
Ejercicio bsico de Restar dos nmeros en consola en C#:
using System.Linq;
using System.Text;
namespace Resta
{
class Program
{
{
int num1, num2, resta;

Console.Write("\n\tResta de Dos Numeros");


//Realizando la Resta
resta = num1 - num2;
9
Console.WriteLine("El Resultado es: " + resta);
//Detener pantalla
Console.ReadKey();
}
}
}
MULTIPLICACIN:
Ejercicio bsico de multiplicacion dos nmeros en consola en C#:
using System;
using System.Linq;
using System.Text;
namespace Multiplicacion
{
class Program
{
{
int num1, num2, multi;
10
Console.Write("\n\tMultiplicacion de Dos Numeros");


//Realizando la Multiplicacion
multi = num1 * num2;
Console.WriteLine("El Resultado es: " + multi);
//Detener pantalla
Console.ReadKey();
}
}
}
11
DIVISIN:
Ejercicio bsico de division dos nmeros en consola en C#:
using System;
using System.Linq;
using System.Text;
namespace division
{
class Program
{
{
int num1, num2, divi;

Console.Write("\n\tDivision de Dos Numeros");


//Realizando la Division
divi = num1 / num2;
Console.WriteLine("El Resultado es: " + divi);
//Detener pantalla
Console.ReadKey();
}
}
}
12
Ensamblador
SUMA:
Ejercicio bsico de sumar dos nmeros en Turbo Debugger Assembler de intel
Instruccin ADD
Propsito: Adicin de los operandos.
Sintaxis:
ADD destino, fuente
Suma los dos operandos y guarda el resultado en el operando destino.
Debe haber correspondencia entre los tamaos de los registros, es decir:

no se puede sumar a un registro de 16, un registro de 8 y viceversa
ADD AX, BX; AX = 0A11, BX = 00A2
ADD AX,AB; AX = AB3
13
14
RESTA:
Instruccin SUB
Propsito: Substraccin
Sintaxis:
SUB destino, fuente
Resta el operando fuente del destino.
SUB AX, BX; AX = 0A11, BX = 00A2
SUB AX,AB; AX = 096F
15
MULTIPLICACIN:
Instruccin MUL
Propsito: Multiplicacin sin signo
Sintaxis:
MUL fuente
El ensamblador asume que el multiplicando ser del mismo tamao que el del
multiplicador, por lo tanto multiplica el valor almacenado en el registro que se le da como
operando por el que se encuentre contenido en AH si el multiplicador es de 8 bits o por AX
si el multiplicador es de 16 bits.
Cuando se realiza una multiplicacin con valores de 8 bits el resultado se almacena en el

registro AX y cuando la multiplicacin es con valores de 16 bits el resultado se almacena
en el registro par DX:AX.
MUL, dl AX: 0005 DX: 0010
AX: 0050
16
DIVISIN:
Ejercicio bsico de Divisin de dos nmeros en Turbo Debugger Assembler de intel
Instruccin DIV
Propsito: Divisin sin signo
Sintaxis:
DIV fuente
El divisor puede ser un byte o palabra y es el operando que se le da a la instruccin.
Si el divisor es de 8 bits se toma como dividendo el registro de 16 bits AX y si el divisor es

de 16 bits se tomara como dividendo el registro par DX:AX, tomando como palabra alta
DX y como baja AX.
Si el divisor fu un byte el cociente se almacena en el registro AL y el residuo en AH, si fu

una palabra el cociente se guarda en AX y el residuo en DX.
DIV dl AX: 0010 DX:000 AX:0103
17
Jassm
SUMA:
Ejercicio bsico de sumar dos nmeros en Jasmin Assembler
.class public suma

aload_0
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma
18
.method public ()
aload_0
Return
.end method
.method public static main([Ljava/lang/String;)V
.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
Aaload
astore 1
; get a
aload_0
iconst_1
Aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
Aaload
istore_3
; new Suma
new suma;
Dup
invokespecial Calculator/<init>()V
; branch if not add
aload_1
ldc "add"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_ADD
; add
iload_2
iload_3
invokevirtual Calculator/add
19
istore 4
; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println
return
NOT_ADD:
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
Return .end method
RESTA:
Ejercicio bsico de restar dos nmeros en Jasmin Assembler
.class public Restar

.method public <init>()V
aload_0
invokespecial java/lang/Object/<init>()V
Return
.end method
.method public sub(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
isub
istore_3
iload_3
ireturn
.end method
.class public Resta
.method public ()V
aload_0
invokespecial java/lang/Object/()V
return
.end method
.limit stack 10
20
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1
; get a
aload_0
iconst_1
aaload
istore_2
; get b
aload_0
iconst_2
aaload
istore_3
; new resta
new resta
Dup
; branch if not sub
aload_1
ldc "sub"
ifeq NOT_SUB
; sub
iload_2
iload_3
invokevirtual Calculator/sub(II)I
istore 4
; print result
iload 4
invokevirtual java/io/PrintStream/println(I)V
return
NOT_SUB:
21
Return .end method
.
MULTIPLICACIN:
Ejercicio bsico de Multiplicar dos nmeros en Jasmin Assembler
.class public Multiplicacion

aload_0
Return
.method public mul(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
imul
istore_3
iload_3
ireturn
.end method
.class public multiplicacion
.method public ()V
aload_0
return
.end method

.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1
22
; get a
aload_0
iconst_1
aaload
istore_2
; get b
aload_0
iconst_2
aaload
istore_3
; new multiplicacin
new multiplicacin
Dup
; branch if not mul
aload_1
ldc "mul"
ifeq NOT_MUL
; mul
iload_2
iload_3
invokevirtual Calculator/mul(II)I
istore 4
; print result
iload 4
return
NOT_MUL:
return
.end method
23
DIVISIN:
Ejercicio bsico de Division dos nmeros en Jasm+in Assembler
.class public divisin

aload_0
Return
.method public div(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
Idiv
istore_3
iload_3
ireturn
.end method
.class public ExeCalculator
.method public ()V

aload_0
return
.end method

.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1
24
; get a
aload_0
iconst_1
aaload
istore_2
; get b
aload_0
iconst_2
aaload
istore_3
; new divisin
new divisin
Dup
; branch if not div
aload_1
ldc "div"
ifeq NOT_DIV
; div
iload_2
iload_3
invokevirtual Calculator/div(II)I
istore 4
; print result
iload 4
Return
NOT_DIV:
return
.end method
25
CICLOS O BUCLES
Un bucle es una instruccin o conjunto de instrucciones que se repite un nmero

especificado de veces o hasta que se cumpla alguna condicin. El tipo de bucle que deba
utilizar depender de la tarea de programacin y de sus preferencias a la hora de escribir
cdigo.
FOR
El bucle for o ciclo for es una estructura de control en programacin en la que se puede
indicar de antemano el nmero mnimo de iteraciones que la instruccin realizar.1 Est
disponible en casi todos los lenguajes de programacin imperativos.
While
El bucle while o bucle mientras es una estructura de la mayora de los lenguajes de
programacin estructurados cuyo propsito es repetir un bloque de cdigo mientras una
condicin se mantenga verdadera.
Do-While
El bucle do, bucle hacer, hacer-mientras o tambin llamado ciclo do-while, es
una estructura de control de la mayora de los lenguajes de
programacin estructurados cuyo propsito es ejecutar un bloque de cdigo y repetir la
ejecucin mientras se cumpla cierta condicin expresada en la clusula while. La diferencia
con el bucle while radica en que este evala la condicin al principio, y si esta no se
cumple, el cdigo que est encerrado dentro del cuerpo no se ejecuta. En cambio, el bucle
do-while evala la condicin para seguir ejecutndose luego de haber ejecutado el cdigo
dentro de su cuerpo; es decir, siempre se ejecuta por lo menos una vez el cdigo.
26
Ejemplos C#
FOR
Ms abajo se muestra cmo crear el mismo bucle utilizando la palabra clave for:
public class suma {
public static void main (String [] args) {
int LIMITE = 100 ;
int suma = 0 ;
for ( int cont = 1 ; (cont <LIMITE) ; cont ++) {
SUMA = (SUMA + cont) ;
}
System. cabo .println (( "\ nLa sumatoria de" Los Primeros
+ (+ LIMITE ( "nmeros es"
+ (SUMA + "\ n" ))))) ;
}
}
27
While
Las versiones del bucle while se muestran en los ejemplos siguientes:
Programa que imprime los nmeros pares entre el 1 y el 10(para hacerlo corto)
main(){
int i=1;
while(1!=10){
i++;
if(i%2==0){
printf(i);
DO-WHILE
Las versiones del bucle do-while se muestran en los ejemplos siguientes:
Lea 3 nmeros y mande a pantalla, cual nmero es el mayor as como el nmero menor, si
hay nmeros son iguales
using System;
using System.Linq;
using System.Text;
namespace tresnumeros
{
class Program
{
{
int A, B, C, D, E;
string AUX;
Console.WriteLine("DAME EL PRIMER NUMERO");
AUX = Console.ReadLine();
A = int.Parse(AUX);
Console.WriteLine("DAME EL SEGUNDO NUMERO");
B = int.Parse(AUX);
Console.WriteLine("DAME EL TERCER NUMERO");
C = int.Parse(AUX);
28
Console.WriteLine("\n\n\n");
if (A == B && B == C)
{
Console.WriteLine("LOS NUMEROS SON IGUALES");
}
else
{
if (A > B && A> C )
{
if (B > C)
{
Console.WriteLine("EL NUMERO MAYOR ES " + A);

Console.WriteLine("EL NUMERO MENOR ES " + C);
D = A % 5;
E = C % 3;
}
Ensamblador
FOR
ORG 100 /El origen del programa es Hex 100
LDA ADS /Cargar primera direccin de operadores
STA PTR /Almacena en apuntador
LDA NBR /Cargar menos de 100
CLA /Borrar el acumulador /
LOP, ADD PTR I /Sumar un operador a AC
ISZ OTR /Incrementa Apuntador
29
ISZ CTR /Incrementar Contador
BUN LOP /Repetir Ciclo
STA SUM/ Almacenar Suma
HLT /Detener
ADS, HEX 100/Permitir direcciones de operadores
PTR, HEX 0/Esta posicin sta reservada para una posicin
NBR, DEC-100 /Constante para el contador inicializado
CTR, HEX0/Esta posicin sta reservada para un contador
SUM, HEX0/La suma esta almacenada aqu
ORG 100 /El origen de los operadores es HEX 100
DEC 75 /Primer operador
Dec 23 /Ultimo operador
END
While
Programa que imprime los nmeros pares entre el 1 y el 10(para hacerlo corto)
30
Do-While
.model small
.stack 64
.data
mayor1 Db 'Es mayor','$'
menor1 Db 'Es menor','$'
igual1 Db 'Son iguales','$'
.code
inicio:
mov ah,01
int 21h
mov bl,al
mov ah,01
int 21h
mov cl,al
cmp bl,cl
ja mayor
jb menor
je igual
mayor:
mov ax,@data
31
mov ds,ax
mov ah,09
mov dx,offset mayor1
int 21h
jmp salir
menor:
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset menor1
int 21h
jmp salir
igual:
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset igual1
int 21h
jmp salir
salir:
mov ah,4ch
int 21h
end inicio
Jasmine
Jasmin es un ensamblador para la Mquina Virtual Java, el cual toma como entrada un
fichero de texto con la descripcin de una clase Java, y produce como resultado el class de
esa clase
FOR
Method void main(java.lang.String[])
bipush 100
istore_1
iconst_0
32
istore_2
iconst_1
istore_3
goto 17
iload_2
iload_3
iadd
istore_2
iinc 3 1
iload_3
iload_1
if_icmplt 10
getstatic #13
new #6
dup
ldc #2
invokespecial #10
iload_1
invokevirtual #11
ldc #3
invokevirtual #12
iload_2
invokevirtual #11
ldc #1
invokevirtual #12
invokevirtual #15
invokevirtual #14
return
ENTRADA & SALIDA

En un programa, los datos de entrada son los que la computadora va a procesar. Los datos
de salida son datos derivados, es decir, obtenidos a partir de los datos de entrada. Por esta
razn, a los datos de salida se les considera ms significativos que a los datos de entrada.
Ambos tipos de datos son informacin (textos, imgenes, sonidos, vdeos,...) que maneja la
computadora. Sin embargo, en un sentido ms filosfico, a los datos de entrada se les
considera la materia prima de los datos de salida, considerados estos como la verdadera
informacin.
33
Ejemplos en C#
ENTRADA & SALIDA:

class Suma {
int A, B, C;
//Se crean variables de tipo entero que se llamarn A, B y C
string AUX;
Console.WriteLine("Introduce el primer nmero");
//Pide que se introduzca un nmero como entrada
//Manda a pantalla lo que se puso entrecomillado
A = int.Parse(AUX);
Console.WriteLine("Introduce el segundo nmero");
B = int.Parse(AUX);
Console.WriteLine("Introduce el tercer nmero");
C = int.Parse(AUX);
Console.WriteLine(Tus nmero a sumar son: A+B+C);
}
}
class Resta {
int A, B, C;
34
string AUX;
A = int.Parse(AUX);
B = int.Parse(AUX);
C = int.Parse(AUX);
Console.WriteLine(Tus nmeros a restar son: A+B+C);
}
}
class Multiplicar {
int A, B, C;
string AUX;
35
A = int.Parse(AUX);
B = int.Parse(AUX);
C = int.Parse(AUX);
Console.WriteLine(Tus nmero a multiplicar son: A+B+C);
}
}
class Division {
int A, B, C;
string AUX;
A = int.Parse(AUX);
B = int.Parse(AUX);
36
C = int.Parse(AUX);
Console.WriteLine(Tus nmero a dividir son: A+B+C);
}
}
Ejemplos en Ensamblador
ENTRADA & SALIDA:

Al posicionarnos sobre la fila cs:0100>0363 estamos introduciendo las variables o datos
que queremos utilizar, en este caso add ax,bx y es all cuando el Turbo Assembler los lee y
les da salida mostrndolos en la pantalla.
A continuacin se hace lo mismo pero con la lectura y salida de las variables que
acompaan a la resta:
37
Ejemplos en Jassm
ENTRADA & SALIDA:

A continuacin, mediante el siguiente fragmento de programa de la clase Suma notaremos
los mtodos de entrada y salida de los datos a utilizar en Jassm:
.class public suma

aload_0
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma
38
.method public ()
aload_0
Return
.end method
.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
Aaload
astore 1
; get a
aload_0
iconst_1
Aaload
istore_2
; get b
aload_0
iconst_2
Aaload
istore_3
; new Suma
new suma;
Dup
; branch if not add
aload_1
ldc "add"
ifeq NOT_ADD
; add
iload_2
iload_3
invokevirtual Calculator/add
istore 4
39
; print result
iload 4
invokevirtual java/io/PrintStream/println
return
NOT_ADD:
Return .end method
ESTRUCTURAS
PILAS
Puesto que la coleccin de lista estndar tiene un encabezamiento y un final, resulta fcil
crear una coleccin de lista derivada que imite el comportamiento de una pila en la que el
ltimo en entrar es el primero en salir. Una pila es como una pila de bandejas de una
cafetera. A medida que se agregan bandejas a la pila, se van colocando en la parte superior
de la pila. La ltima bandeja agregada es la primera en quitar. Las funciones miembro de
una coleccin de lista AddHead y RemoveHead se pueden utilizar para agregar y quitar
elementos especficamente del principio de la lista; por tanto, el ltimo elemento agregado
es el primero que se quita.
COLAS
Puesto que la coleccin de lista estndar tiene un encabezamiento y un final, resulta fcil
crear una coleccin de lista derivada que imite el comportamiento de una cola en la que el
primero en entrar es el primero en salir. Una cola es como una fila de gente en una
cafetera. La primera persona de la fila es la primera a quien se sirve. A medida que llega
ms gente, estas personas se sitan al final de la fila para esperar que les llegue su turno.
Las funciones miembro de una coleccin de lista AddTail y RemoveHead se pueden
utilizar para agregar y quitar elementos especficamente del encabezamiento o del final de
la lista; por tanto, el ltimo elemento agregado es siempre el ltimo que se quita.
40
LISTAS
Son una sucesin de cero o ms elementos. Esta es una definicin muy simple y que no
aclara demasiado en trminos informticos, as que profundizaremos un poco ms. Hay
varios tipos de listas, las hay enlazadas, no enlazadas, ordenadas y no ordenadas. Nosotros
vamos a estudiar las listas enlazadas, tanto ordenadas como no ordenadas. La diferencia
que existe entre las listas enlazadas y las no enlazadas es que las enlazadas utilizan
punteros, es decir, asignacin dinmica de memoria, lo que optimiza la gestin de la
misma. Una lista no enlazada es un simple array, y por lo tanto es un bloque contiguo de
memoria, mientras que una lista enlazada es un conjunto de nodos que no tienen porque
Ocupar posiciones contiguas de memoria. La diferencia entre listas ordenadas y no

ordenadas es obvia, las ordenadas mantienen cierto orden entre sus elementos. A partir de
ahora nos centraremos en las listas enlazadas no ordenadas. Una lista es una sucesin de
nodos en la que a partir de un nodo se puede acceder al que ocupa la siguiente posicin en
la lista. Esta caracterstica nos indica que el acceso a las listas es secuencial y no indexado,
por lo que para acceder al ltimo elemento de la lista hay que recorrer los n-1 elementos
previos (n es el tamao de la lista).
ARREGLOS
Es una coleccin de datos del mismo tipo. Sirve para manejar un nmero n de elementos
en comn, ya sea de tipos definidos por el Lenguaje,(int,float,String,etc) as como
aquellos definidos por el programador.
Un arreglo unidimensional es un tipo de datos estructurado que est formado de una
coleccin finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar
listas de elementos iguales. El tipo de acceso a los arreglos unidimensionales es el acceso
directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o posteriores, esto mediante el uso de un ndice para cada elemento
del arreglo que nos da su posicin relativa.
41
Ejemplos en C#
Pilas
Para crear una pila, emplearemos la clase Stack. Una pila nos permitir introducir un nuevo
elemento en la cima ("apilar", en ingls "push") y quitar el elemento que hay en la cima
("desapilar", en ingls "pop").
Este tipo de estructuras se suele denotar tambin usando las siglas "LIFO" (Last In First
Out: lo ltimo en entrar es lo primero en salir).
Para utilizar la clase "Stack" y la mayora de las que veremos en este tema, necesitamos
incluir en nuestro programa una referencia a "System.Collections".
As, un ejemplo bsico que creara una pila, introdujera tres palabras y luego las volviera a
mostrar sera:
using System;
using System.Collections;
public class Ejemplo_11_02a

{
public static void Main()
{
string palabra;
Stack miPila = new Stack();

miPila.Push("Hola,");
miPila.Push("soy");
miPila.Push("yo");
for (byte i=0; i<3; i++)

{
42
palabra = (string) miPila.Pop();
Console.WriteLine( palabra );
}
}
}
LISTAS:
Sea LISTA una lista enlazada, salvo que se indique lo contrario. Almacenaremos LISTA en
memoria de la forma siguiente. Como mnimo, LISTA estar compuesta por dos arrays
lineales, a los que llamaremos INFO y ENLACE, tales que INFO [K] y ENLACE [K]
contienen la parte de informacin y el campo de puntero de cada nodo de LISTA
respectivamente. Necesitamos tambin una variable especial llamada COMIENZO que
contiene la posicin ocupada por el primer elemento de la lista, y una marca especial
NULO que indica el final de la misma. Puesto que los ndices de los arrays INFO y
ENLACE sern habitualmente positivos, el valor NULO ser el -999, salvo que digamos lo
contrario.
El siguiente ejemplo muestra la representacin memoria de una lista enlazada en la que

cada nodo de la lista contiene un nico carcter. Podemos obtener la lista de caracteres o,
en otras palabras, la cadena de la forma siguiente:
COMIENZO = 9, luego INFO [9] = N primer carcter.
ENLACE [9] = 3, luego INFO [3] = 0 segundo carcter.
ENLACE [3] = 6, luego INFO [6] = (carcter blanco) tercer carcter.
ENLACE [6] = 11, luego INFO [11] = E cuarto carcter.
43
ENLACE [11] = 7, luego INFO [7] = X quinto carcter.
ENLACE [7] = 10, luego INFO [10] = I sexto carcter.
ENLACE [10] = 4, luego INFO [4] = T sptimo carcter.
ENLACE [4] = -999 valor nulo, luego termina la lista.
FORMA PRINCIPAL DE LA LISTA ENLAZADA
Cdigo:
using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication1
public partial class Listas : Form
public Listas()
InitializeComponent();
public static int[] enlace = new int[10] { 2, 3, 4, 0, -999, 6, 7, 8, 9, -999 };
44
public static string[] alumno = new string[10] { "Jose", "Ana", "Rosa", "Beto", "zeta",
"", "", "", "", "" };
public static int comienzo = 1;
public static int disponible = 5;
private void cmdInsercion_Click(object sender, EventArgs e)
Insercion ins = new Insercion();
ins.Show();
private void cmdRecorrido_Click(object sender, EventArgs e)
Recorrer rec = new Recorrer();
rec.Show();
private void cmdBusqueda_Click(object sender, EventArgs e)
Busqueda bus = new Busqueda();
bus.Show();
private void cmdEliminacion_Click(object sender, EventArgs e)
45
Eliminacion eli = new Eliminacion();
eli.Show();
ARREGLOS:
Matrices multidimensionales
Conceptualmente, una matriz multidimensional con dos dimensiones se asemeja a una
cuadrcula. Una matriz multidimensional con tres dimensiones se asemeja a un cubo.
C#
// declare multidimension array (two dimensions)
int[,] array2D = new int[2,3];
// declare and initialize multidimension array

int[,] array2D2 = { {1, 2, 3}, {4, 5, 6} };
// write elements in a multidimensional array

for (int i=0; i<2; i++)
{
for (int j=0; j<3; j++)
{
array2D[i,j] = (i + 1) * (j + 1);
}
}
// read elements in a multidimensional array

for (int i=0; i<2; i++)
{
for (int j=0; j<3; j++)
{
System.Console.Write(array2D[i,j]);
}
System.Console.WriteLine();
Ensamblador
PILAS:
46
.model small
.stack 64
.data
.code
mov ah 4h;
mov dx, Hola;
int 21
mov ah 3h;
mov dy soy;
int 20
mov ah,2h
mov db yo;
int 21h
push ax
loop meter
mov ah,4h
imprimir:
pop ax
mov ah,2h
mov dl,al
int 21h
loop imprimir
salir:
mov ah,3ch
int 21h
end
LISTAS
; Insercin de un elemento en una lista ordenada.
; La lista est almacenada a partir de la direccin definida por LISTOR y est
; constituida por elementos de 1 palabra de longitud expresados en binario puro.
; Estn ordenados de menor a mayor y estn almacenados en posiciones de memoria
; Consecutivas. El tamao de la lista est almacenado en la direccin
; LONLIS y el elemento a insertar est almacenado en la variable NUEVO.
; La lista no almacena elementos repetidos.
47
org 1000
LISTOR: data 1,3,7,45,56,67,101,200
org 2000
LONLIS: data 8
NUEVO: data 90
;Tras la ejecucion del programa los contenidos de memoria son:
; 992 01000000 03000000
; 1008 07000000 2D000000 38000000 43000000
; 1024 5A000000 65000000 C8000000 00000000
; 2000 09000000 5A000000
Jassm
LAS INSTRUCCIONES BIPUSH, SIPUSH Y IINC
Las instrucciones bipush y sipush toman un entero como un parmetro:
bipush <int>
sipush <int>
por ejemplo:
bipush 100; empujar 100 en la pila
La instruccin IINC toma dos parmetros enteros:
IINC <var-num> <cantidad>
por ejemplo:
IINC 3 -10; restar 10 de variable local 3
48
LA INSTRUCCIN NEWARRAY:
La instruccin newArray es seguido por el tipo de la matriz,
newArray <tipo array>
por ejemplo:
newArray int
newArray corta
flotador newArray
etctera
LA INSTRUCCIN MULTIANEWARRAY:
La instruccin multianewarray toma dos parmetros, el descriptor de tipo para la matriz y el

nmero de dimensiones para asignar:
multianewarray <array-descriptor> <num-dimensiones>
por ejemplo:
multianewarray [[[I 2
LA INSTRUCCIN LOOKUPSWITCH:
La instruccin lookupswitch tiene la sintaxis:
<Lookupswitch> :: =
lookupswitch
<INT1>: <label1>
<INT2>: <label2>
...
por defecto: <default-label>

Por ejemplo:
; Si el int en la pila es 3, saltar a Label1.
49
; Si es 5, saltar a Label2.
; De lo contrario saltar a DefaultLabel.
lookupswitch
3: Label1
5: Label2
por defecto: DefaultLabel
label1:
... Tiene 3
label2:
... Tiene 5
DefaultLabel:
... Tiene algo ms
LA INSTRUCCIN TABLESWITCH:
La instruccin tableswitch tiene la sintaxis:
<Tableswitch> :: =
tableswitch <bajos>
<Label1>
<Label2>
...
por defecto: <default-label>
Por ejemplo:
; Si el int en la pila es 0, saltar a Label1.
50
; Si es 1, saltar a Label2.
; De lo contrario saltar a DefaultLabel.
tableswitch 0
label1
label2
por defecto: DefaultLabel
label1:
... Conseguido 0
label2:
... Consigui 1
DefaultLabel:
51
BIBLIOGRAFIA
Anon, (2017). [online] Available at: https://msdn.microsoft.com/es-

es/library/cc451506(v=vs.71).aspx [Accessed 16 Mar. 2017].

es/library/9ct4ey7x(v=vs.90).aspx [Accessed 16 Mar. 2017].

es/library/6sh2ey19(v=vs.110).aspx [Accessed 16 Mar. 2017].
Carlosnuel.com. (2017). Tutorial de lenguaje ensamblador. [online] Available at:

http://www.carlosnuel.com/tutorial-de-lenguaje-ensamblador-en-espanol-con-
ejemplos.html [Accessed 16 Mar. 2017].
Hernndez, L., Hernndez, L. and perfil, V. (2017). Codigo Fuente Hola Mundo. [online]
Asembler-uaeh-esh.blogspot.mx. Available at: http://asembler-uaeh-
esh.blogspot.mx/2009/10/hola-mi-queridos-alumnos.html [Accessed 16 Mar. 2017].
52

C# en Visual

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C# en Visual

Transféré par

Droits d'auteur :

Formats disponibles

INSTITUTO NACIONAL DE MXICO

Gmez Gonzales Citlalli

Morales Hernndez Yazmin Yareli

Palomar Aguirre Jael

Solano Uscanga Maril

Martnez Moreno Martha

ADD destino, fuente

Suma los dos operandos y guarda el resultado en el operando destino.

Debe haber correspondencia entre los tamaos de los registros, es decir:

ADD AX,AB; AX = AB3

.class public suma

En C#, un operador es un elemento de programa que se aplica a uno o varios operandos en

~x Negacin bit a bit

x+y Suma, concatenacin de cadenas, combinacin de delegados

x-y Resta, eliminacin de delegados

//Explicacion del Ejercicio

//Ingresando el primer numero

//Ingresando el primer numero

//Explicacion del Ejercicio

//Ingresando el primer numero

//Ingresando el primer numero

//Ingresando el primer numero

//Ingresando el primer numero

//Explicacion del Ejercicio

//Ingresando el primer numero

//Ingresando el primer numero

Propsito: Adicin de los operandos.

ADD destino, fuente

Suma los dos operandos y guarda el resultado en el operando destino.

Debe haber correspondencia entre los tamaos de los registros, es decir:

ADD AX, BX; AX = 0A11, BX = 00A2

ADD AX,AB; AX = AB3

SUB destino, fuente

Resta el operando fuente del destino.

SUB AX, BX; AX = 0A11, BX = 00A2

SUB AX,AB; AX = 096F

Propsito: Multiplicacin sin signo

Cuando se realiza una multiplicacin con valores de 8 bits el resultado se almacena en el

MUL, dl AX: 0005 DX: 0010

Propsito: Divisin sin signo

El divisor puede ser un byte o palabra y es el operando que se le da a la instruccin.

Si el divisor es de 8 bits se toma como dividendo el registro de 16 bits AX y si el divisor es

Si el divisor fu un byte el cociente se almacena en el registro AL y el residuo en AH, si fu

DIV dl AX: 0010 DX:000 AX:0103

.class public suma

.class public Restar

.class public Multiplicacion

.method public static main([Ljava/lang/String;)V

Ejercicio bsico de Division dos nmeros en Jasm+in Assembler

.class public divisin

.method public ()V

.method public static main([Ljava/lang/String;)V

Un bucle es una instruccin o conjunto de instrucciones que se repite un nmero

Console.WriteLine("EL NUMERO MAYOR ES " + A);

LDA ADS /Cargar primera direccin de operadores

STA PTR /Almacena en apuntador

LDA NBR /Cargar menos de 100

CLA /Borrar el acumulador /

LOP, ADD PTR I /Sumar un operador a AC

ISZ OTR /Incrementa Apuntador

BUN LOP /Repetir Ciclo

STA SUM/ Almacenar Suma

ADS, HEX 100/Permitir direcciones de operadores