lunes, 22 de noviembre de 2010

Caracteristicas de Java


Simple

Java es un lenguaje potente, pero sin las caracteristicas que hacen ser confuso a este tipo de lenguajes. Java fué diseñado para ser precedido por C++ y facilitar un fácil aprendizaje. En java no es necesario preocuparse por liberar memoria, el reciclador solo lo hace y además reduce la fragmentación de memoria.
En java se reduce hasta en un 50% los errores comúnes de programaci{on en lenguajes como C y C++ ya que elimina muchas caracteristicas de estos lenguajes, principalmente:

  • aritmética de punteros
  • no existen referencias
  • registros (struct)
  • definición de tipos (typedef)
  • macros (#define)
  • necesidad de liberar memoria (free)

Bueno en realidad las clases son uan estructura parecida a lo que es struct.

Es un lenguaje orientado a objetos

Esto quiere decir que java trabaja con sus datos como si estos fueran objetos y que tienen interfaces a esos objetos. Soporta tres caracteristicas de los lenguajes orientados a objetos ENCAPSULAMIENTO, HERENCIA y POLIMORFISMO.
Las plantillas de objetos son llamadas clases y tienen sus propias instancias. Java tambi{en incorpora la resolución dinamica de métodos.
Las clases en java tienen una representación en runtime que les permite a los programadores preguntar por el tipo de clase con el resultado de la busqueda.

Es distribuido

Java tiene extensas capacidades de interconeción TCP/IP. Hay librerias de rutinas conlas que se puede interactuar con los protocolos http y ftp. Con esto es posible acceder a información en la red mucha facilidad como si fueran ficheros locales.
Java es capaz de proporcinar herramientas necesarias para que los programas sean distribuidos, esto quiere decir que púedan correr en otras máquinas, interactuando.

Es robusto

Java puede realizar verificaciones en busca de problemas ya sea en tiempo de ejecución o en tiempo de compilación. La comprobación de tipos en java ayuda a detectar errores en el ciclo de desarrollo.
Se tiene que declarar explicitamente las clases para as{i poder evitar errores.

Es dinámico

No pretende conectar todos los módulos de la aplicación hasta el tiempo de ejecución.


Y además simplifica el uso de protocolos nuevos y actualizados.

Referencias

domingo, 21 de noviembre de 2010

Multiparadigmas Reporte

Los lenguajes de programación multiparadigma son aquellos lenguajes que soportan en un mismo programa más de un estilo de programación.
El motivo de la existencia de estos lenguajes es permitir al programador diseñar los códigos de la mejor forma, admitiendo que ningun paradigma es capaz de cumplir con las funciones especiales de otro.
Por ejemplo hay lenguajes de programación que permiten combinar la programación imperativa con la orientación a objetos, un ejemplo de eso puede ser C++, Basic, PHP entre otros. Otro buen ejemplo puede ser Prolog que ya lo utilizamos y nos dimos cuenta que apesar de su naturaleza de ser un lenguaje lógico, también permite combinar estructuras imperativas.

Bueno este reporte consiste en hacer un programa en algun lenguaje multiparadigma, yo elegí Go, batallé bastante con él ya que tiene muy pocos tutoriales en internet, solo hay el de la página oficial(todo en inglés) y uno más(también en inglés), además ahora no me pude apoyar de los blogs de mis compañeros porque no veo nada referente al tema bueno hice un programa muy sencillo(paradigma imperativo) que me muestra en pantalla la serie del 5, aunque bien pudiera ser otro número cualquiera solo cambiandolo en la variable, no pudé leer un dato que el usuario introdujera, es poreso que decidí hacer esto, bueno este es el código:


package main

import "fmt"

func main() {
var a int

var c int

c = 5

fmt.Printf("La serie del 5 :)...\n")

for n := 1; n < 11; n++ {
a = n * c
fmt.Printf("%d ,", a)
}
}


Y la ejecución

ubuntu@ubuntu:~/Desktop$ 8g ejemplo.go
ubuntu@ubuntu:~/Desktop$ 8l ejemplo.8
ubuntu@ubuntu:~/Desktop$ ./8.out

Go

Hola compañeros, les voy a mostrar como instalar go en ubuntu.
Primero se ocupa abrir el archivo ~/.bashrc

Y agregar unas líneas necesarias al final...


Por si no se alcanzan a ver bien son:
export GOROOT=$HOME/go
export GOOS=linux
export GOARCH=386
export GOBIN=$HOME/bin
export PATH=$PATH:$GOBIN

Y ahora tecleamos: source ~/.bashrc


Y creamos un nuevo directorio al que se le tiene que llamar $GOBIN

Enseguida instalamos mercurial con el comando:
sudo apt-get install mercurial


También instalamos este paquete:
sudo apt-get install bison gcc lib6-dev ed

hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Ahora nos ubicamos en el directorio donde se instalo go, por defecto es /go/src

Ahora tenemos que ejecutar dentro de ese directorio el comando ./all.bash no pude hacer una captura de pantalla porque rápidamente se corrieron las líneas, pero creo que es clara la instrucción.

Una vez terminado podemos compilar con el comando:

8g programa.go
8l programa.8

Y ejecutar:
./8.out

Cualquier corrección o duda, pueden comentar con confianza :D

Lenguajes orientados a objetos Reporte

C++
En este lenguaje cree una clase a la que llamé Áreas y esta contiene varios métodos para obtener las áreas de un cuadrado, rectángulo, circulo y triángulo. Todos los métodos y atributos los declaré público. La manera de definir los métodos se hace con el nombreclase::nombremetodos la forma de llamarlos es escribiendo simplemente el nombre del método.

#include <iostream>

using std::cout;
using std::endl;
using std::cin;

// Esto crea la clase Areas
class Areas {
public:
float resultado;
void triangulos(float largo, float ancho);
void cuadrado(float lados);
void circulo(float radio);
void rectangulo(float largo, float ancho);
};


/* implementar trangulos() */
void Areas :: triangulos(float x, float y)
{
resultado = (x * y)/2;
cout << "El area del triangulo es:" << endl;
cout << resultado << endl;
return;
}


/* implementar cuadrado() */
void Areas :: cuadrado(float lados)
{
resultado = lados * lados;
cout << "El area del cuadrado es:" << endl;
cout << resultado << endl;
return;
}

void Areas :: rectangulo(float x, float y)
{
resultado = x * y;
cout << "El area del rectangulo es:" << endl;
cout << resultado << endl;
return;
}

void Areas :: circulo(float radio)
{
resultado = 3.1416 * radio * radio;
cout << "El area del circulo es:" << endl;
cout << resultado << endl;
return;
}


int main (int argc, char** args)
{
// crear 2 objetos CRender
Areas area1;
int opcion;
float lados, x, y, radio;
cout << "Elige una opción" << endl;
cout << "1.-Area cuadrado" << endl;
cout << "2.-Area circulo" << endl;
cout << "3.-Area triangulo" << endl;
cout << "4.-Area rectangulo" << endl;
cin >> opcion;

switch (opcion)
{
case 1: cout << "Cual es el lado del cuadrado" << endl;
cin >> lados;
area1.cuadrado(lados);
break;
case 2: cout << "Cual es el radio del circulo" << endl;
cin >> radio;
area1.circulo(radio);
break;
case 3: cout << "Cual es la base del triangulo" << endl;
cin >> x;
cout << "Cual es la altura del triangulo" << endl;
cin >> y;
area1.triangulos(x, y);
break;
case 4: cout << "Cual es la base del rectangulo" << endl;
cin >> x;
cout << "Cual es la altura del rectangulo"<< endl;
cin >> y;
area1.rectangulo(x, y);
break;

default: cout << "Elija una opcion entre 1 y 4";
}

return (0);
}


Ejecución


Python
En python cree una ventanita con un botón y una programa parecido al que hicimos en clase, tiene una clase a la que llamé Ciudad, esta clase tiene nombre de ciudad y numero de habitantes, hicé uso de self.
Ventanita:


#!/usr/bin/env python
import pygtk
pygtk.require("2.0")
import gtk

class VentanaBoton:

def __init__(self):
self.window=gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(50)
self.button = gtk.Button("Botoncito")
self.window.add(self.button)
self.button.show()
self.window.show()



def main(self):
gtk.main()

if __name__ == "__main__":
ventanita = VentanaBoton()
ventanita.main()

Ejecución:


Y programa con la clase ciudad:

#!/usr/bin/env python
class Ciudad:
def __init__(self, nombre, numhabitantes):
# Asignamos valores a los atributos
self.nombrec = nombre
self.habitantes = numhabitantes
def getNombre(self):
return self.nombrec

def getNumeroHabitantes(self):
return self.habitantes


def main():
ciudad1 = Ciudad("NY", 100000)
ciudad2 = Ciudad("PARIS", 400000)


print ciudad1.getNombre()
print ciudad1.getNumeroHabitantes()
print ciudad2.getNombre()
print ciudad2.getNumeroHabitantes()

main()

Ejecución:


Y en java
Este lenguaje en su caracteristica de orientado a objetos ya lo conocía, no como python y C++ que son totalmente nuevos para mí, sin embargo si tuvé que volver a leer sobre algunas funciones que ya no recordaba exactamente que hacian, bueno el primer programita que hice en java es una ventana que tiene dos botones:


import javax.swing.*;
import java.awt.*;
class Programita extends JFrame {
JButton uno = new JButton("Primero");
JButton dos = new JButton("Anterior");

Programita(){
//Añadimos el formato de FlowLayout al JFrame
this.setLayout(new FlowLayout());
//Añadimos componentes
add(uno);
add(dos);
setTitle("Ejemplos simple java");
setSize(200,200);
setVisible(true);
}

public static void main (String []args){
new Programita();
}

}


Ejecución:


Y uno más que detecta el movimiento del ratón en la ventana y escribe en el terminal las coordenadas.


// componentes GUI
import javax.swing.*;
import java.awt.*;


// eventos
import java.awt.event.*;


public class Prueba extends JPanel // es un panel (para dibujo)
implements MouseListener, // escucha eventos de raton
MouseMotionListener, // de movimiento del cursos
ActionListener { // de botones
protected double px, py;
public Prueba(){
super(); // siempre llamar primero a super si extends
super.setBackground(Color.BLACK); // color de fondo
this.addMouseListener(this); // registrar escuchadores
this.addMouseMotionListener(this);
}


public void actionPerformed(ActionEvent e){
// que fue solicitado
String cmd = e.getActionCommand();

if (cmd.equals("EXIT")) { // si quieren salir
System.exit(1); // salir del programa
}
return;
}

public void mouseClicked(MouseEvent e){

return;
}

public void mouseEntered(MouseEvent e){

return;
}

public void mouseExited(MouseEvent e){

return;
}

public void mousePressed(MouseEvent e){

return;
}

public void mouseReleased(MouseEvent e){

return;
}

public void mouseDragged(MouseEvent e){

return;
}

public void mouseMoved(MouseEvent e){
this.px = e.getX();
this.py = e.getY();
System.out.println("Movieron " + px + " , " + py);

return;
}

public static void main(String args[]){
JFrame v = new JFrame(); // ventana
v.setTitle("Mueves el mousee!!!");
v.setLocation(250, 250); // posicionar
v.setSize(500, 300); // ajustar tamano
v.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanel auxi = new JPanel(); // panel auxiliar
auxi.setLayout(new BorderLayout()); // acomodo
auxi.setBackground(Color.WHITE); // debug

Prueba o = new Prueba(); // el panel principal de dibujo

// poner los botones en otros paneles auxiliares

// para salir
JButton b = new JButton("Salir");
b.addActionListener(o);
b.setActionCommand("EXIT");
JPanel p = new JPanel();
p.add(b);
auxi.add(p, BorderLayout.SOUTH);
// poner todo el contenido a la ventana
auxi.add(o, BorderLayout.CENTER);
v.setContentPane(auxi);
v.setVisible(true);
return;
} // termina main(...)


}



Ejecución:

Compilador de Cobol

Como me tarde en conseguir el compilador es probable que alguien más este en la misma situación, entonces les voy a compartir el compilador que yo encontré, para compilar en este lenguaje lo primero que ocupamos hacer es:
Descargar el compilador rmcobol de la siguiente página:


enseguida debemos descomprimirlo, y ubicarnos en el terminal en la carpeta descomprimida, teclear el siguiente comando:

sudo ./rminstall

ahora damos varias veces [ok], y aparecerá algo así:

y ya tenemos nuestro compilador :D, para comprobar que funciona escribimos en el terminal rmcobol, y tenemos que ver la siguiente pantalla:


Ahora podemos crear nuestros programas.cbl y compilarlos con el siguiente comando

rmcobol programa.cbl

y ejecutarlo ./programa





C Multiplicación de matrices y el método montante

Hola compañeros les muestro como se hace la multiplicación de matrices en C:




#include <stdio.h>


int main(int argc, char** args){
int af, ac, bf, bc, i, j, k;
printf("Numero de renglonesde la matriz A-->");
scanf("%d", &af);
printf("Numero de columnas de la matriz A-->");
scanf("%d", &ac);
printf("Numero de renglones de la matriz B-->");
scanf("%d", &bf);
printf("Numero de columnas de la matriz B-->");
scanf("%d", &bc);
if(ac!=bf){
printf("no es posible hacer la multiplicación\n");
system("pause");
return 0;
}
int A[af][ac], B[bf][bc], C[af][bc]; /*Rutina para cargar los valores*/
for(i=0;i<af;i++){
for(j=0;j<ac;j++){
printf("Escribe el valor de la matriz 1 (%d, %d)-->",i+1, j+1);
scanf("%d", &A[i][j]);
}
}
printf("\n\n");
for(i=0;i<bf;i++){
for(j=0;j<bc;j++){
printf("Escribe el valor de la matriz 2 (%d, %d)-->", i+1, j+1);
scanf("%d", &B[i][j]);
}
}

for(i=0;i<af;i++){
for(j=0;j<bc;j++){
C[i][j]=0;
for(k=0;k<ac;k++){
C[i][j]=(C[i][j]+(A[i][k]*B[k][j]));
}
}
}

/*Rutina para imprimir*/
printf("\n\n\t\t\t Matriz A");
printf("\n");
for(i=0;i<af;i++){
printf("\n\t\t");
for(j=0;j<ac;j++){
printf(" %6d ", A[i][j]);
}
}
printf("\n\n\t\t\t Matriz B");
printf("\n");
for(i=0;i<bf;i++){
printf("\n\t\t");
for(j=0;j<bc;j++){
printf(" %6d ", B[i][j]);
}
}

printf("\n\n\t\t\t Matriz C");
printf("\n");
for(i=0;i<af;i++){
printf("\n\t\t");
for(j=0;j<bc;j++){
printf(" %6d ", C[i][j]);
}
}
printf("\n");
}


Ejecución:




Y el método Montante, este es un código que empecé el semestre pasado, hoy lo retomé y lo he podido concluir :D, este es el código:


#include<stdio.h>
#include <stdlib.h>
#define R 3
#define C 4

int main (void){

int i, j, num[R][C], matriz[R][C], pivote, pivant = 1, iteracion = 0;
//Lectura
for(i=0;i<R;i++){
for(j=0;j<C - 1;j++){
printf("Los valores de la matriz [%d,%d]= ",i + 1, j + 1);
scanf("%d",&matriz[i][j]);
}
printf("El costo fue----------------> ");
scanf("%d",&matriz[i][j]);
}

while(iteracion < R) {
pivote = matriz[iteracion][iteracion];
for(i=0;i<C;i++) {
num[iteracion][i] = matriz[iteracion][i];
}
for(i=0;i<R;i++) {
if(iteracion != i) {
num[i][iteracion] = 0;
}
}
for(i=0;i<R;i++){
for(j=0;j<C;j++){
if(i != iteracion) {
if( j!= iteracion) {
num[i][j] = (((matriz[i][j] * pivote) - (matriz[iteracion][j] * matriz[i][iteracion])) / pivant);
}
}
}
}

iteracion++;
pivant = pivote;
for(i=0;i<R;i++) {
for(j=0;j<C;j++) {
matriz[i][j] = num[i][j];

}
}
}
printf("\n\n\n\n");
for(i=0;i<R;i++){
printf("\t\t");
for(j=0;j<C - 1;j++){
printf("\t%d",matriz[i][j]);
}
printf("\t= %d\n", matriz[i][j]);
}
return 0;
}


Ejecución:



Cualquier duda sobre alguna línea o sugerencia comenten con confianza :D

Python Python Python ...

Laboratorio

Python fué desarrollado por Guido van Rossum, es posible programar en python utilizando programación lineal, estructurada y orientada a objetos.

Python tiene interpretes en distintas plataformas: Windows, Linux, Mac, etc. Es posible desarrollar con este lenguaje aplicaciones web. Google, Yahoo, Nasa etc. utilizan python para sus desarrollos.
Es posible programar en python desde una línea de comandos o creando archivos.py.

¿Qué podemos hacer con python?
  • Aplicaciones que se ejecutan en un servidor web(lo que se puede hacer con PHP, Ruby, ASP.net, JSP), para poder practicar esto de aplicaciones web sería muy bueno tener una cuenta de Google App Engine y crear algo usando como lenguaje de servidor Python.
  • Aplicaciones de escritorio con interfaces visuales.
  • Scripts que tengan como objetivo sistematizar procesos de administración de equipos.
  • Aplicaciones para celulares.

Características de python

Python nos permite programar con tres metodologías:
  • Programación lineal: Cuando hacemos código y no hay funciones en el.
  • Programación estructurada:Es cuando hay varias funciones que realizan actividades distintas, y luego se mandan llamar dentro del programa, las funciones pueden estar en el mismo programa o en alguna librería separada.
  • Programación orientada a objetos: Se basa en clases en la definición de objetos.

Objetos
Los objetos son entidades independientes que contienen sus propios datos y programación.
La tecnología orientada a objetos es la suma de funciones a elementos de datos, lo que se llama encapsulamiento. Un ejemplo puede ser el objeto página que se puede decir que tiene los atributos de anchura, altura, color, estilo de borde, etc., etc. Entonces se encuentran los métodos para modificar los atributos(tamaño de la página, colores, etc., etc.), esa página tiene responsabilidades de un objeto que podría consistir en hacer acciones apropiadas y mantener los datos internos actualizados. Cuando otros objetos pudieran necesitar que la página realize alguna cosa como cambiar de color le envía un mensaje. Pero a estos objetos que están enviando el mensaje no les interesa la manera en que el objeto página lleva a cabo sus tareas ni las estructuras, es por eso que están ocultos. Un objeto puede contener la información pública o privada.

Declaración de una clase
La POO se basa en la programación de clases y no en funciones como la programación estructurada.
Se puede decir que una clase es como un molde del que después se pueden crear varios objetos, con características muy similares.
En las clases se definen los atributos y métodos comunes a estos objetos, para que después cada objeto cuente con sus propios valores y las mismas funciones.
Lo primero que se debe de hacer antes de crear un objeto es crear una clase. Cuando se crea una instancia de clase se puede decir que se esta creando una instancia o un objeto.
Ejemplo:

class Persona:
def inicializar(self,nom):
self.nombre=nom

def imprimir(self):
print 'Nombre:'
print self.nombre
print '<br>'

persona1=Persona()
persona1.inicializar('Juan')
persona1.imprimir()

persona2=Persona()
persona2.inicializar('Ana')
persona2.imprimir()

En ese ejemplo se tiene que nombre es un atributo y los métodos son las dos funciones.
Todos los métodos deben de tener el parámetro self que contiene la referencia del objeto que hizó llamada al método.
La manera de diferenciar los atributos dentro del método antecediendo self:
self.nombre=nom.
Con la asignación previa se almacena en el parámetro nom, los atributos siguen existiendo cuando finaliza la ejecución del método y es por eso que se puede mostrar el nombre que cargamos en el primer método.


Atributos de una clase

Los atributos son cualidades, características y propiedades distributivas de cada clase. Tienen información sobre los objetos, determinan la apariencia, estado y más propiedades distintivas de cada clase.
Cuando se crea un objeto de una clase determinada, los atributos son declarados por la clase se localizan en la memoria y se pueden modificar mediante métodos.

Métodos de una clase

Los métodos son como las funciones en lenguajes estructurados, solo que se definen dentro de una clase y operan en los atributos de esa misma clase.
Los métodos son como las responsabilidades de las clases, la manera de encontrar las responsabilidad de las clases podría ser preguntándose qué puede hacer la clase.
Un método tiene como objetivo ejecutar actividades que tiene encomendada la clase a la cual pertenece.
Los atributos de los objetos se modifican mediante las llamadas a sus métodos.

Método constructor de una clase

Este es un método especial de clase, se puede decir que el objetivo fundamental del constructor es inicializar los atributos del objeto que se creo.

Ventajas de constructores
  • Cuando se crea un objeto el constructor es el primer método en ejecutarse.
  • El constructor no necesita ser llamado, se llama automaticamente.


Características de los constructores:
  • Se ejecuta inmediatamente luego de ser creado el objeto y no es posible llamarlo nuevamente.
  • No retorna datos.
  • No recibe parámetros que se
  • Es opcional.

Ejemplo:

def __init__([parámetros]):
[algoritmo]


Llamar métodos dentro de la clase:
Se utiliza la sintaxis:
[nombre del objeto].[nombre del método]
Es decir antecedemos al nombre del método el nombre del objeto y el operador punto, si se quiere pasar en la clase a otro método que pertenece a la misma clase, la sintaxis es la siguiente:
self.[nombre del método]
Se debe tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.


Referencias

C++ Laboratorio

C++ es un lenguaje de programación orientado a objetos, se puede decir que es un C mejorado, ya que C la unidad principal es la función lo que hace que sea una programación orientada a acciones y en C++ es la clase y a partir de ella los objetos son producidos, lo que hace que se mejore la productividad, calidad y reutilización del software.

La salida de flujo se hace con el operador de inserción de flujo <<.
Las palabras claves de C++ están en minúsculas, en este lenguaje igual que en C importa la diferencia entre mayúsculas y minúsculas. Las palabras reservadas en C++:

  • auto
  • continue
  • enum
  • if
  • short
  • switch
  • volatile
  • break
  • default
  • extern
  • int
  • signed
  • typedef
  • while
  • case
  • do
  • float
  • long
  • sizeof
  • union
  • char
  • double
  • for
  • register
  • static
  • unsigned
  • const
  • else
  • goto
  • return
  • struct
  • void
Esa lista son palabras reservadas para C y C++, la lista de a continuación tiene las palabras reservadas solamente de C++.
  • asm
  • catch
  • class
  • delete
  • friend
  • inline
  • new
  • operator
  • private
  • protected
  • public
  • template
  • this
  • try
  • virtual
Los comentarios de de la manera ya conocida // y /*..*/.
En C++ las variables pueden ser declaradas dentro del ciclo for terminando su alcance al finalizar el ciclo, pero es importante no confundir esto las variables NO PUEDEN ser colocadas en las condiciones de las estructuras do while, while, for o if.
La manera de imprimir y leer datos en C++ si es diferente C en vez de utilizar printf se utiliza cout con el operador << y en vez de scanf se usa cin y el operador >>, la diferencia con C de estos operadores es que no se requiere cadenas de formatos y de especificadores de conversión para indicar los tipos de datos que entran y salen.
Para poder hacer uso de cin y cout es necesario agregar el archivo de cabecera iostream.h

Tipos de datos en C++
Las palabras reservadas en c++ para crear tipos de datos definidos por el usuario son enum, struct,union y class.Cuando se declara algún dato tipo enum, struct, class o union se esta declarando un nuevo tipo de dato.

Parámetros
En C++ se tienen que declarar todos los parámetros de las funciones entre los paréntesis, una función que no recibe parámetros se especifica escribiendo void o simplemente los paréntesis vacíos.

Funciones en linea
Hay funciones llamadas en linea que ayudan a reducir la sobrecarga de las funciones, especial para pequeñas funciones. El compilador puede ignorar la instrucción inline a excepción de las funciones pequeñas.Inline debe ser utilizado solo para funciones pequeñas de uso frecuente.Esto lo podemos observar en el siguiente programa:


// Usamos la función inline para calcular el volumen de un cubo.
#include <iostream.h>
inline float cubo( const float s ) { return s * s * s; }
main( )
{
cout << ''Introduce la longitud del lado de tu cubo: '';
float lado;
cin >> lado;
cout << ''El volumen del cubo de lado ''
<< lado << ''es'' << cubo( lado ) << '\n';
return 0;
}


Parámetros por referencia
Los parametros por referencias son "alias" de su argumento correspondiente. Para pasar parametros por referencia es necesario indicar con un ampersand(&) despues haber indicado el tipo de parametro en el prototipo de la función.
Se usan APUNTADORES para pasar argumentos que pueden ser modificados por la funcion a la que se llama, se usan REFERENCIAS a constantes para mandar argumentos que no se van a modificar.
Las variables de referencia deben ser iniciadas en sus declaraciones.

CONST
Es utilizado en los parametros de una fucnion para indicar que ese valor no debe ser modificado en esa funcion.La variable constante debe ser INICIALIZADA al declararse.
Tambien es usado para declarar un apuntador constante.
const tipo nombre = valor; //Tipo constante
tipo *const nombre = valor; //Apuntador constante a tipo.
const tipo *nombre = valor; //(Variable) apuntador a la constante tipo.
const tipo *const nombre = valor; //apuntador constante a tipo constante.

Asignación dinamica de memoria con new y delete
Delete y new son dos operadores que deben ser utilizados el uno con el otro new se utiliza para dar un espacio de memoria a una variables segun su tipo, devuelve un apuntador, si no es posible asignar memoria devuelve un apuntador nulo, y delete se utiliza para desasignar memoria, el espacio que es creado con new solo se puede deshacer con delete.

Operador de resolucion con alcance unario.
Concepto fácil de entender, se refiere a cuando tenemos dos variables que tienen el mismo nombre una local y otra global, entonces es posible dentro de la funcion donde esta la variable local llamar a la variabe global mediante :: , pero es posible utilizarlo cuando se quiere acceder a una variable local de otra funcion.
Ejemplo:


#include <iostream.h>
float v;
int main( )
{
int v = 7;
::v = 10.5; // Utilizar la variable global v
cout << ''variable local v = '' << v << ''\n'';
cout << ''variable global v = '' << ::v << ''\n'';
return 0;
}


Homonimia de funciones
Este es un tema del que ya hablé en este blog(liga), es lo mismo que sobrecarga de funciones, esto quiere decir tener dos funciones que tienen el mismo nombre pero que es posible distinguirla por los parametros de la función.

Plantillas de función
Plantillas de funcion es cuando se pueden utilizar varias funciones que hagan las mismas operaciones pero con distintos tipos de datos. La plantilla de función se define solamente una vez. Las definiciones de plantillas se deben de hacer con template y la lista de parametros formales(precedidos por la palabra class) a la plantilla de función entre corchetes(<>).

C++ (POO)
Clases
Las clases es donde el programador diseña objetos que estan compuestos por atributos y comportamiento.Son definidos mediante la palabra class.
Una vez que se a declarado la clase ese nombre de clase puede ser utilizado para declarar objetos de dicha clase.
Ejemplo:

class Punto
// Declaración de la clase Punto.
{
int _x, _y; // Coordenadas del punto.
public:
// Principio de la declaración de interface.
void setX (const int val);
void setY (const int val);
int getX( ) {return _x;}
int getY( ) {return _y;}
};
Punto apunto; // Definición del objeto apunto.


Las definciones de clases se hacen con la palabra reservada class, el cuerpo de la función esta delimitado mediante llaves y termina con ; dentro del cuerpo de la función se pueden escribir las etiquetas public y private, cuando un miembro se declara public, quiere decir que se puede acceder a ellos siempre que el programa tenga acceso a un objeto de la clase y private solo se puede acceder a el en las funciones miembro de la clase.
Por defecto los elementos de las clases son PRIVADOS.

Los miembros de las clases no se pueden inicializar en el cuerpo de la clase donde son declarados. Se inician por el constructor de la clase, o la función "set" les podrán asignar valores.
Los destructores de clases tienen el mismo nombre que la clase pero va precedido por (~).

Acceso a miembros
Se puede acceder a los miembros de clase privados solo por miembros amigos de la misma clase.
Se puede acceder a los miembros de clase publicos mediante cualquier funcion del programa.

El apuntador this
Los objetos tienen apuntadores a si mismos que se llaman this, puede ser utilizado explicita(mediante el uso de la palabra this) o implícitamente.
El apuntador this se utiliza de manera implícita cuando se quiere referenciar a los miembros de datos y a las funciones miembro de un objeto. Este apuntador this depende del tipo de objeto y de si es const la función miembro donde this es utilizado.
Ejemplo:

// Declaramos un objeto fecha1 y a continuación le enviamos el
// mensaje set_fecha.
fecha1.set_fecha( );
// C++ define el puntero this para apuntar al objeto fecha1 de la
// forma:
Cfecha *const this = &fecha1;


// La función set_fecha puede ser definida también de la siguiente
// forma:
void Cfecha::set_fecha( )
{
cout << ''día, ## : ''; cin >> this->dia;
cout << ''mes, ## : ''; cin >> this->mes;
cout << ''año, #### : ''; cin >> this->anyo;
}


Referencias:
Manual de programación en C++.
C++ Tutorial.

lunes, 15 de noviembre de 2010

C Matriz transpuesta

Materia: Lenguajes de Programación-Puntos extras

Una matriz esta compuesta de filas(reng) y columnas(col), la matriz transpuesta es una matriz que cambia las columnas por las filas.



Implementé mi programa en C, de la siguiente forma:
Primero se incluye la librería <stdio.h> y enseguida defino la variable MAX y el doy un valor de 10, esto es para poder declarar la matriz y que tenga ese número máximo de filas y columnas, y podemos modificar ese valor máximo directamente en el código del programa.
Enseguida declaro mi función principal int main(int argc, char** args), y dentro de ella empiezo a escribir todo el código, se declaran las variables que voy a usar, todas son de tipo enteros tengo la variable matriz[MAX][MAX], reng, col, i=0 y j=0, matriz es el arreglo bidimensional que el usuario va a llenar, reng y col indical el numero de renglones y columnas que el usuario quiera, y la i y j se utilizan como auxiliares para ir leyendo las posiciones del arreglo, después también nos auxiliamos de ellas para imprimir la matriz original, y la matriz transpuesta.
Entonces ahora empiezo a leer los datos del usuario, con dos for uno cumple la función de ir llenando la fila y el otro de saltar al siguiente fila para que sea llenada, es posible que se preste a confusión, la parte de mi código en donde pido al usuario que inserte una valor para cada posición del arreglo ya que tengo "i+1" y "j+1", es simplemente para que se vea "bonito", si no el código empezaría diciendo "Escriba los valores [0][0]", para mi es mejor que se vea [1][1], después de que se cumple el ciclo de llenado, ahora se pasa a la rutina para imprimir los valores de forma de una matriz, para que el usuario pueda comparar la matriz original a la matriz transpuesta, después de la rutina de imprimir la matriz original, viene el "truco", imprimir la matriz transpuesta es muy sencillo solo se intercambia en el for el orden en que se impriman los datos, en vez de imprimir matriz[i][j], se imprime matriz[j][i].
El %6d lo utilicé para dar espacio entre los números.

El código:


#include<stdio.h>
#define MAX 10
int main(int argc, char** args)
{
int matriz[MAX][MAX], col, reng, i=0, j=0;
printf("Cuantas columnas quieres ");
scanf("%d", &col);
printf("Cuantos renglones quieres ");
scanf("%d", &reng);
for(i = 0;i < reng;i++)/*RUTINA PARA LEER LOS DATOS*/
{
for(j = 0;j < col;j++){
printf("ESCRIBE LOS VALORES [%d][%d]==>\t", i+1, j+1);
scanf("%d", &matriz[i][j]);
}
}
printf("\n\n\t\tMatriz original");/*RUTINA PARA IMPRIMIR*/
printf("\n\n");
for(i = 0;i < reng;i++){
printf("\n\t\t");
for(j = 0;j < col;j++){
printf(" %6d ", matriz[i][j]);
}
}
printf("\n\n\t\tMatriz transpuesta");/*IMPRIMIR MATRIZ TRANSPUESTA*/
printf("\n\n");
for(i = 0;i < col;i++){
printf("\n\t\t");
for(j = 0;j < reng;j++){
printf(" %6d ", matriz[j][i]);
}
}
printf("\n\n\n");
}




Ejecuciónes:



Código para descargar aquí.

Tipos de datos-Presentación


Este es mi vídeo habla de una estructura pacientes, espero lo vean y comenten, también esta publicado el código para que lo vean o lo descarguen.



Y el código:

#include<stdio.h>
#define N 25

struct dato{
char telefono[N];
char correo[N];
};

typedef struct dato dat;

typedef struct{
char nombre[N];
char edad[3];
char n_cuenta[N];
char enfermedad[N];
dat contactar;
}pacientes;

FILE *archivo;

void agregar(void) {
pacientes x;
archivo = fopen("registro.txt", "w");
printf("\n\n\t****Altas****\n");
printf("\n\tNombre: ");
scanf(" %[^\n]s", x.nombre);
printf("\n\tEdad: ");
scanf(" %[^\n]s", x.edad);
printf("\n\tNumero de cuenta: ");
scanf(" %[^\n]s", x.n_cuenta);
printf("\n\tEnfermedad: ");
scanf(" %[^\n]s", x.enfermedad);
printf("\n\tCorreo: ");
scanf(" %[^\n]s", x.contactar.correo);
printf("\n\tTelefono: ");
scanf(" %[^\n]s", x.contactar.telefono);
printf("\n\t****Los datos se tomaron correctamente****");
printf("\n\t %s %s %s %s %s %s\n", x.nombre, x.edad, x.n_cuenta, x.enfermedad, x.contactar.correo, x.contactar.telefono);
fprintf(archivo, "\n %s %s %s %s %s %s", x.nombre, x.edad, x.n_cuenta, x.enfermedad, x.contactar.correo, \
x.contactar.telefono);

fclose(archivo);
return;
}

void consultar(void) {
system("clear");
char palabra[100];
char *c;
archivo = fopen("registro.txt", "r");
if (archivo == NULL)
{
printf("Error al abrir el archivo \n");
return;
}

do
{
c = fgets(palabra, 100, archivo); /* Obtiene una linea del archivo */
if (c != NULL)
printf("%s\n", palabra); /* La despliega en pantalla */
}
while (c != NULL); /* Se repite hasta encontrar NULL */
fclose(archivo);
return;
}



int main(void) {
int op = 1;
do{
printf("\n\t¿Quieres agregar pacientes(1) o consultar el registo(2)?\n");
scanf("%d", &op );
switch(op){
case 1:
agregar();
break;
case 2:
consultar();
break;
default:
printf("opcion no valida\n");
}
}while(op != 1 && op != 2);
}



Y la descarga aquí.

Compilador Algol68

Laboratorio
Hola compañeros, hace algunas semanas en clase aprendí a instalar el compilador de Algol con la ayuda de la profesora claro, lo primero que se hace es descargar la carpeta de las siguiente página:

http://sourceforge.net/projects/algol68/

después extraemos la carpeta, y abrimos el terminal y nos ubicamos en la dirección de la nueva carpeta, por ejemplo yo la cree en el escritorio entonces accedo de esta manera:



Ahora ejecutamos el shell configure de la siguiente manera:

./configure


Enseguida escribimos "make", y veremos algo como esto:


y ahora escribimos "make install", después de eso ahora:

sudo apt-get install libncurses5-dev



Y ahora para ver que el compilador funciona correctamente escribimos:

./a68g

si todo funciona bien veremos algo como esto:


Ahora estamos listos para probar el compilador algol68, antes de empezar aquerer hacer nuestros códigos es bueno primero ejecutar algunos que funcionen correctamente, pero batallé bastante para hallar ejemplos en la web que corrieran sin errores, pero podemos probar los códigos que vienen de muestra con el compilador, en la carpeta demos, es importante saber que los programas tienen la extensión .a68 y se compilan de la siguiente forma ./a68g nombre.a68
Aquí esta la imágen de un código compilado:


Si hay algún problema comenten :D.