Autor Tema: Subrutinas en VC++6  (Leído 5416 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado migsantiago

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8257
    • Sitio de MigSantiago
Subrutinas en VC++6
« en: 18 de Febrero de 2006, 20:25:00 »
Hola de nuez

En un programa que estoy haciendo hay una rutina que se ejecuta en cualquiera de estas situaciones:

if(seg_actual>seg_previo)
{
rutina ...
}

o en esta

if((seg_previo==59)&&(seg_actual==0))
{
misma rutina...
}

Para no escribir la rutina después de cada IF podría poner una OR, pero quiero hacerlo de otra forma, llamar una subfunción para cada IF, es decir:

if(seg_actual>seg_previo)
llama_subrutina();

if((seg_previo==59)&&(seg_actual==0))
llama_subrutina();

Pero cuando creo una subfunción en el archivo cpp me manda un error de que esa función no es miembro del diálogo:

void llama_subrutina(void);
{
mi código...
return 0;
}

¿Cómo le hago para que funcione? Llorica

Gracias por cualquier sugerencia

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: Subrutinas en VC++6
« Respuesta #1 en: 19 de Febrero de 2006, 00:21:00 »
Migsantiago, parece que vas necesitando que el jefe Todopic cree un nuevo subforo dedicado a la programación en Visual C++.

No tengo ni idea de C++, ¿pero no se resuelve el problema si declaras tu función con anterioridad a su uso?

Desconectado migsantiago

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8257
    • Sitio de MigSantiago
RE: Subrutinas en VC++6
« Respuesta #2 en: 19 de Febrero de 2006, 08:57:00 »
Es que en VC++ las rutinas llevan "clases"... cosa que no entiendo al 100%.

Digamos que cuando presionas un botón de tu ventana llamas una subfunción:

CCDialog::OnBotón()
{
código
}

Así las genera VC, pero si yo quiero hacer una propia me regaña y manda un error de función miembro, y la verdad no sé que onda. Muchas risas

Lo que se de VC es por un tutorial PDF y hasta ahí. Avergonzado


Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
RE: Subrutinas en VC++6
« Respuesta #3 en: 19 de Febrero de 2006, 13:33:00 »
Lo que te tienes que crear es una clase, ahora mismo tengo que irme, pero esta noche me comprometo a comentar un poco como funcionan. Pero vete indagando como funciona el asistente para crear clases(boton derecho->add class), veras que te crea un constructor y un destructor y luego puedes crear funciones y demas. Luego esta noche me intentare explicar algo mejor.

Por cierto seria muy interesante lo del subforo de C++, se pueden hacer muchas cosas.

Tutoriales y proyectos de electrónica

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: Subrutinas en VC++6
« Respuesta #4 en: 19 de Febrero de 2006, 14:21:00 »
Pues si, creo que es muy interesante. A ver si el jefe nos lee y tiene a bien crearlo.

Desconectado microcarsil

  • PIC10
  • *
  • Mensajes: 44
RE: Subrutinas en VC++6
« Respuesta #5 en: 19 de Febrero de 2006, 15:01:00 »
Estaria estupendo que se creera un subforo para visual c++ ya que hay muchos amigos que estamos comenzando.  Por otra parte migsantiago con lo referente a crear tu funcion void llama_rutina(void) es como comenta nocturno66 tienes que declararla con anterioridad (vas a la pestaña de abajo classsView y en tu clase principal con terminacion CMiclaseDlg haces clic derecho y despues clic en Add member function, en el tipo especificas void y en la declaracion llama_rutina(void), y con eso ya puedes utilizarla en tu archivo .cpp), aunque también estoy comenzando con visual c++ Sonrisa Gigante espero haber sido de ayuda.
Microcarsil

Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
RE: Subrutinas en VC++6
« Respuesta #6 en: 19 de Febrero de 2006, 17:03:00 »
Bueno, ya estoy aqui. A ver si se explicar un poco genericamente como funcionan las clases en POO y que es la Programacion Orientada a Objetos en sí.

Bueno, lo primero de todo es saber la utilidad de la programación orientada a objetos(POO) con respecto a la programacion procedural que usamos con los PIC al programar en C. La mayor ventaja que tenemos con PPO es la reutilizacion del codigo en posteriores proyectos, una clase que nos creemos por ejemplo para enviar datos por el puerto serie nos servira en adelante en todos los proyectos que hagamos que necesiten transferencia serie. Simplemente tendremos que adjuntar los ficheros de la clase a nuestro programa.

Los conceptos basicos de la POO son:

-Objetos:Un objeto es una entidad que tiene unos atributos propios (datos) y unas formas de manipularlos(los métodos o funciones miembro). Es decir, un objeto incluye, por una parte una serie de operaciones que definen su
comportamiento, y una serie de variables manipuladas por esas funciones que
definen su estado. Por ejemplo, una ventana Windows tiene operaciones
como “maximizar” y variables como “ancho” y “alto”.

-Clases. Una clase es la definición de un tipo de objetos. De esta manera, una clase “Complejo” representaría todos los numeros complejos, mientras
que (2+2i) seria un objeto de esa clase.

-Métodos. Un método es una función creada dentro de un objeto con la
finalidad de realizar una serie de operaciones sobre los datos que contiene. En el ejemplo de lso numeros complejos por ejemplo seria la suma de complejos.

-Mensajes:Un programa basado en objetos, utiliza como mecanismo de
comunicación entre los mismos una serie de métodos que pueden ser llamados
por agentes externos al objeto. A la acción de ejecutar métodos externamente a un objeto se le denomina mensaje. Por ejemplo, cuando decimos a Windows que
deseamos ver el escritorio, y que por tanto todas las ventanas abiertas deben
minimizarse, Windows se encarga de enviar mensajes de minimización a todas
las ventanas que en ese momento está gestionando.

Bueno ademas de estos elementos propios de la POO, esta tiene unaqs caracteristicas muy utiles:

-Abstraccion: Nos permite relacionar en una clase todos los elementos que posean caracteristicas similares aunque no sean iguales, por ejemplo una clase "coches", etc.

-Encapsulamiento: Nos permite actuar sobre un objeto perteneciente a una clase a modo de caja negra, sin importarnos los que se produce dentro de ella, ni como se produce.

-Herencia: Se pueden heredar unas clase de otras, haciendo cada clase hija mas expecifica pero no teniendo que volver a implementar los metodos comunes. Por ejemplo, si tenemos una clase "vehiculos", en ella ya estara implementado el metodo "moverVehiculo", si hacemos una clase heredada "motocicletas" esta no tendra que implementar de nuevo ese metodo.

-Polimorfismo: El mismo metodo nos servira para diferentes objetos, incluso actuando de diferente forma y haciendo cosas distintas, siguiendo con el ejemplo anterior, no funcionara igual moverVehiculo cuando se trate de una motocicleta que cuando se trate de un avion, pero ambos se moveran utilizando cada uno el mismo metodo pero que conlleva acciones distintas.

Tutoriales y proyectos de electrónica

Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
RE: Subrutinas en VC++6
« Respuesta #7 en: 19 de Febrero de 2006, 17:16:00 »
Ahora ya hecha la introduccion os voy a hablar de las clases:

Como he comentado una clase es el "contenedor" de datos relativos a un conjunto de objetos con caracteristicas comunes y de unos metodos para trabajar con ellos. En cuanto a como esta estructurada una clase, os comento de que esta compuesta siempre:

-Constructor: Siempre que creemos un objeto de una clase, se llamara al constructor para que lo construya.

-Destructor: Es el que destruye el objeto una vez que ya no lo usemos.

Estos dos metodos, siempre deben estar en una clase, ademas decir que siempre que creamos una clase con el asistente en VC++ nos los crea por defecto y luego podemos añadirle otros nuestros.

Desspues tenemos las variables y los metodos que creemos en la clase.

Para finalizar os voy a poner un ejemplo de la primera clase que hice cuando estaba aprendiendo, es una clase de numeros complejos, en ella se puede ver muy bien otro concepto del que no he hablado y que es muy importante, la sobrecarga de operadores, que consiste en que podemos utilizar operadores que ya tienen mision asignad( como el + o el -) pra que hagan otra cosa que nosotros queramos dentro de la clase.

/***************************************************************
FICHERO:   complejo.h
***************************************************************/

#ifndef __COMPLEJO_H__
#define __COMPLEJO_H__
#include <iostream.h>
class Complejo
 {
 private:// estos son los atributos de los objetos de la clase
    double real;
    double imag;
 public://aqui pongo los metodos
    // Constructores
    Complejo(void);
    Complejo(double, double im=0.0);
    Complejo(const Complejo&);
    // Set Cosas
    void setReal(double);
    void setImag(double);
    // Get Cosas
    double getReal(void){return real;}
    double getImag(void){return imag;}
    // Sobrecarga de operadores aritméticos
    Complejo operator+ (const Complejo&);
    Complejo operator- (const Complejo&);
    Complejo operator* (const Complejo&);
    Complejo operator/ (const Complejo&);
    Complejo& operator= (const Complejo &a);
   // Sobrecarga del operador de asignación
    // Sobrecarga del operador de inserción en el flujo de salida
    friend ostream& operator<< (ostream&, const Complejo&);
   friend istream& operator>> (istream&, Complejo&);
   
};
#endif

/***************************************************************
FICHERO:   complejo.cpp
***************************************************************/

#include "Complejo.h"

 // constructor por defecto
Complejo::Complejo(void)
 {
 real = 0.0;
 imag = 0.0;
 }
// constructor general
Complejo::Complejo(double re, double im)
 {
 real = re;
 imag = im;
 }
// constructor de copia
Complejo::Complejo(const Complejo& c)
 {
 real = c.real;
 imag = c.imag;
 }
// permite asignar solo la parte real
void Complejo::setReal(double re)
 {
 real = re;
 }
// permite asignar solo la parte imaginaria
void Complejo::setImag(double im)
 {
 imag = im;
 }
// operador miembro + sobrecargado (suma)
Complejo Complejo::operator+ (const Complejo &a)
 {
 Complejo suma;
 suma.real = real + a.real;
 suma.imag = imag + a.imag;
 return suma;
 }
// operador miembro - sobrecargado (resta)
Complejo Complejo::operator- (const Complejo &a)
 {
 Complejo resta;
 resta.real = real - a.real;
 resta.imag = imag - a.imag;
 return resta;
 }

// operador miembro * sobrecargado (producto)
Complejo Complejo::operator* (const Complejo &a)
 {
 Complejo producto;
 producto.real = real*a.real - imag*a.imag;
 producto.imag = real*a.imag + a.real*imag;
 return producto;
 }
// operador miembro / sobrecargado (división)
Complejo Complejo::operator/ (const Complejo &a)
 {
 Complejo cociente;
 double d = a.real*a.real + a.imag*a.imag;
 cociente.real = (real*a.real + imag*a.imag)/d;
 cociente.imag = (-real*a.imag + imag*a.real)/d;
 return cociente;
 }
// operador miembro de asignación sobrecargado
// realmente no es necesario, solo es para verlo
Complejo& Complejo::operator= (const Complejo &a)
{
  real = a.real;
  imag = a.imag;
  return (*this);
  }
 
// operador friend << sobrecargado (auto impresión)
ostream& operator << (ostream& co, const Complejo &a)
 {
 co << a.real;
 long fl = co.setf(ios::showpos);
 co << a.imag << "i";
 co.flags(fl);
 return co;
 }
istream& operator>> (istream& ci, Complejo &a)
{
 ci>>a.real;
 ci>>a.imag;
 return ci;
}


Tutoriales y proyectos de electrónica

Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
RE: Subrutinas en VC++6
« Respuesta #8 en: 19 de Febrero de 2006, 17:19:00 »
Y ahora un ejemplo de un programa que utiliza esa clase:

#include "Complejo.h"
#include "iostream.h"


void main(void)
{
   
   /****************************************************************************
   *                                                         *
   *    ESTA PARTE DEL MAIN() CORRESPONDE A LA PRACTICA 2(COMPLEJOS)            *
   *                                                         *
   ****************************************************************************/
   
   //se crean dos complejos con el constructor general
   Complejo c1(1.0, 1.0);
   Complejo c2(2.0, 2.0);
   //se crea un Complejo con el constructor por defecto   
   Complejo c3;
   //se da valor a la parte rea e imaginaria de c3
   c3.setReal(5.0);
   c3.setImag(2.0);
   //se crea un complejo con el valor por defecto (0,0) del 2º argumento
   Complejo c4(4.0);
   //se crea un complejo a partir del resultado de una expresion
   //se utiliza el constructor de copia
   Complejo suma = c1 + c2;
   //se crean tres complejos con el constructor por defecto
   Complejo resta, producto, cociente;
   //se asignan valores con los operadores sobrecargados
   resta = c1- c2;
   producto = c1 * c2;
   cociente = c1 / c2;
   //se imprimen los numeros Complejos con el operador << sobrecargado
   cout << c1 << "," << c2 << "," << c3 << "," << c4 << endl;
   cout << "primer Complejo: " << c1 << endl;
   cout << "primer Complejo: " << c1 << endl;
   cout << "Segundo Complejo: " << c2 << endl;
   cout << "Suma: " << suma << endl;
   cout << "Resta: " << resta << endl;
   cout << "Producto: " << producto << endl;
   cout << "Cociente: " << cociente << endl;
}

Espero que os sirva de ayuda, ya que con los PIC poco os puedo ayudar y en esto no tanto pero puedo aportaros mi granito de arena.

Tutoriales y proyectos de electrónica

Desconectado migsantiago

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8257
    • Sitio de MigSantiago
RE: Subrutinas en VC++6
« Respuesta #9 en: 19 de Febrero de 2006, 21:18:00 »
Gracias 5GTT y Carsil, voy a tener que copiar y pegar sus respuestas para leerlas con calma después. Luego les digo si funcionó o no.

Voy a comentarle a Mr. Todopic a ver que piensa de abrir un subforo, a lado de Visual Basic, para que se vea que aquí en el foro sabemos de todoooooooo Muchas risas

ahh 5GTT, por favor podrías editar tu mensaje quitándole las caritas de miarroba? es que se modificó parte del código Muchas risas

Quita esta opción:

Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
RE: Subrutinas en VC++6
« Respuesta #10 en: 19 de Febrero de 2006, 22:57:00 »
Jeje, no conseguia quitar los caretos xD. Ya esta solucionao.

Por cierto, la opcion que te comentan tambien es valida y seguramente para tu programa ahora mismo sea la via mas rapida de solucionar el problema. El tema de usar clases se fundamenta en la reutilizacion del codigo. Por ejemplo yo tengo una clase USB y en mis poryectos simplemente si quiero mandar algo o recibir por ese puerto pongo SendPaquet o ReceivePaquet y no me preocupo de mas, ya sabe el programa lo que tiene que hacer.

Ya que hablamos de clase, a ver si nos abren un nuevo subforo y comentamos las MFC"s (Microsoft Foundation Classes) que son la caña para hacer interfaces.

Saludos.

Tutoriales y proyectos de electrónica

Desconectado elmasvital

  • Administrador
  • PIC24H
  • *******
  • Mensajes: 1713
RE: Subrutinas en VC++6
« Respuesta #11 en: 20 de Febrero de 2006, 05:49:00 »
Mirad a todos los que os produzca urticaria la POO o escuchar hablar de ella solo deciros que es algo tremendamente sencillo tratado de una forma muy complicada.  Por cierto decir que la POO la he manejao en php pero no en VC++

Y todo esto por el simple hecho de que por ser los mas chulos pues se inventan nuevos nombres para cosas que ya existian... en fin viene a ser mas o menos esto.

objeto -> cualquier cosa de este mundo que tiene unas propiedades comunes y unas funciones comunes... ej: coche-> color marca potencia (atributos) arrancar, parar aparcar (metodos)... osea struct + funciones

Atributo -> pues asi llaman a las variables de los objetos

metodo -> función dentro de una clase

instancia de clase -> un objeto de una clase

herencia entre clases -> tipos definidos por usuario traducido a clases logicamente si existe una clase motor, en la case coche no vas a volver a definir la clase motor... la heredas... que como? pues simplemente creas un objeto de la clase motor dentro de la de coche... asi de simple. Como usar un tipo struct ya definido dentro de otro struct.

Las clases vienen a ser unas estructuras del tipo struct pero que incluyen no solo definiciones de variables si no que se conjugan con funciones, ademas de constructores y destuctores que es como una inicialización del objeto en el momento de crearlo.


Da muchisima vistosidad al codigo aunque tambien algunos inconvenientes. Pero es muy divertido programarlas... al menos a mi me lo parecen en PHP

1 saludo

PD 5GTT si pones
Codigo:
[ c o d e]  [/ c o d e]
te hubiera respetado las tabulaciones del codigo

Desconectado migsantiago

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8257
    • Sitio de MigSantiago
RE: Subrutinas en VC++6
« Respuesta #12 en: 20 de Febrero de 2006, 13:27:00 »
Pues ya nos abrió Mr. Todopic el nuevo subforo Visual C++ ujuuuuuuuuu

Algún moderador podría mover este tema para allá por favor? DivertidoDivertido

Voy a seguir leyendo lo de la POO, está medio difícil Muchas risas Gracias elmasvital

http://miarroba.com/foros/ver.php?foroid=951683

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: Subrutinas en VC++6
« Respuesta #13 en: 20 de Febrero de 2006, 15:29:00 »
i Movido!

Desconectado migsantiago

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8257
    • Sitio de MigSantiago
RE: Subrutinas en VC++6
« Respuesta #14 en: 20 de Febrero de 2006, 15:50:00 »
Ya funcionó tu sugerencia Carsil Muchas risas

De hecho antes yo declaraba variables manualmente en el archivo .h del diálogo, pero con Add member variable... se hace automáticamente. Giño