Publicado por: migsantiago en 18 de Febrero de 2006, 20:25:00
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?
Gracias por cualquier sugerencia
Publicado por: Nocturno en 19 de Febrero de 2006, 00:21:00
No tengo ni idea de C++, ¿pero no se resuelve el problema si declaras tu función con anterioridad a su uso?
Publicado por: migsantiago en 19 de Febrero de 2006, 08:57:00
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.
Lo que se de VC es por un tutorial PDF y hasta ahí.
Publicado por: 5GTT en 19 de Febrero de 2006, 13:33:00
Por cierto seria muy interesante lo del subforo de C++, se pueden hacer muchas cosas.
Publicado por: Nocturno en 19 de Febrero de 2006, 14:21:00
Publicado por: microcarsil en 19 de Febrero de 2006, 15:01:00
espero haber sido de ayuda.
Publicado por: 5GTT en 19 de Febrero de 2006, 17:03:00
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.
Publicado por: 5GTT en 19 de Febrero de 2006, 17:16:00
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;
}
Publicado por: 5GTT en 19 de Febrero de 2006, 17:19:00
#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.
Publicado por: migsantiago en 19 de Febrero de 2006, 21:18:00
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
ahh 5GTT, por favor podrías editar tu mensaje quitándole las caritas de miarroba? es que se modificó parte del código
Quita esta opción:
Publicado por: 5GTT en 19 de Febrero de 2006, 22:57:00
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.
Publicado por: elmasvital en 20 de Febrero de 2006, 05:49:00
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
te hubiera respetado las tabulaciones del codigoCodigo:
[ c o d e] [/ c o d e]
Publicado por: migsantiago en 20 de Febrero de 2006, 13:27:00
Algún moderador podría mover este tema para allá por favor?
Voy a seguir leyendo lo de la POO, está medio difícil
Gracias elmasvitalhttp://miarroba.com/foros/ver.php?foroid=951683
Publicado por: Nocturno en 20 de Febrero de 2006, 15:29:00
Publicado por: migsantiago en 20 de Febrero de 2006, 15:50:00
De hecho antes yo declaraba variables manualmente en el archivo .h del diálogo, pero con Add member variable... se hace automáticamente.
