Portar código de dev-c++ a Visual Studio

[VladisMSX1]

Hola foreros. Estoy intentando portar unas funciones que escribí en dev-c++ y funcionan correctamente a Visual Studio 2010. Me tira problemas por todos lados cuando porto el programa, con cosas como las llamadas system e incluso declaraciones como los for. En total, un código de algo mas de 500 líneas me lanza 64 errores, una barbaridad, y son todos del estilo de:

"Intellisense: Se esperaba una declaración"
"Intellisense: Se esperaba )"
"intellisense: "IMoaUnknownVtbl" no está definido"

Me llega a tirar errores incluso cuando intento usar variables declaradas en una función, diciendome que no están declaradas.

Nunca he usado Visual Studio y no se si tengo que incluir alguna librería o configurar el editor para que me interprete correctamente el código. ¿Alguna ayuda?

Gracias, un saludo

[RyogiShiki]

Sin ver el código va a ser muy dificil ayudarte...

[VladisMSX1]

Decidí no ponerlo porque pensaba que era un problema "genérico" de cualquier código escrito en el compilador Dev-C++ al intentar portarlo a Visual Studio 2010  

Aquí lo pongo:

Código [Seleccionar] Expandir


#include "xtrautil.h"
#include <conio.h>         //Librería de headers, no definida en estandard C
#include <stdlib.h>        //Librería de propósito general para gestión de memoria
#include <iostream>        //Librería de funciones de E/S de datos
#include <stdio.h>         //Librería de funciones E/S Estandard
#include <windows.h>       //Librería de compatibilidad con windows
#include <string.h>        //Definición de macros, constantes, funciones, etc
#include <winsock.h>       //Librería de manejo de sockets Winsock
#define ip "192.168.0.255" //IP del servidor (A la que conectar)
using namespace std;

void doEtherValue( long canal, long valor, XtraInfo * xtraInfo );
{
      int i;
      if ((canal<1) || (canal>512) || (valor>255) || (valor<0))
         {
         system("cls");
         cout<<"ERROR - Numero de canal o valor indicado fuera de rango\nPulsa cualquier tecla para continuar...";
         getch();
         }
      else
          {
          //ARRAY DE SECUENCIA
          char secuencia[1];
          //Aplicamos el valor secuencia al punto CERO, ya que los arrays se definen con el entero de su tamaño, pero su primer valor es el 0, no el 1
          secuencia[0]=0;
         
          //ARRAY DE VALORES DE CANALES
          int k;
          char valores[526];
          for (k=0; k<526; k++)
             {
             valores[k]=0;
             }
          //Asignación del valor al canal
              valores[canal-1]=valor;
         
          /*
           /////////////////////////////////////////////////////////////////////////////
           ||                                                                         ||
           ||                                                                         ||
           ||                            *******CONEXION*******                       ||
           ||                                                                         ||
           ||                                                                         ||
           /////////////////////////////////////////////////////////////////////////////
           */
         
          system("cls");//Borramos la pantalla para eliminar las lineas mostradas en el menú

         /* Primero abrimos el socket Winsock. Tenemos varias opciones para definir
         el tipo de socket que vamos a crear:
               Familia del protocolo:
                       AF_INET: Para conexión con máquinas conectadas a Internet
                       AF-UNIX: Para conexion con máquinas LINUX
                       AF_NS:   Para conexión con máquinas XEROX
                       AF_CCITT:Para conexión con protocolos CCITT,X25...
               Tipo de socket:
                       SOCKET_STREAM: Para TCP
                       SOCKET_DGRAM:  Para UDP
                       SOCKET_RAW:    Para IP
               Protocolo:
                       PPROTO_TCP: Como dice su nombre, para protocolo TCP
                       PPROTO_UDP: Como dice su nombre, para protocolo UDP

         Así pues para una conexión UDP normal, el código sería: */

         WSADATA wsa; // Winshock
         int sock;//Descriptor del socket.
         struct sockaddr_in direccion; //Datos del servidor a conectar

         WSAStartup(MAKEWORD(2,0),&wsa);

         /* -Después creamos una structura (struct), en la que definiremos el tipo de
          -protocolo a utilizar para la conexion,
          -despues el puerto por el que deve conectarse nuestro cliente y
          -por último la ip a la que conectara nuestro cliente. */
         
         char buf[531];       // Tamaño del mensaje a enviar
         int puerto=6454;     // puerto del servidor a conectar
       
         if((sock=socket(AF_INET,SOCK_DGRAM,0))==-1 )
            {
            // Creamos el socket mientras creamos el primer filtro de error
            printf("PROBLEMA AL CREAR EL SOCKET");
            getch();
            exit(0);
            }
         else
           {
           printf("SOCKET CREADO CORRECTAMENTE\n\n");
           /* Ahora procedemos a insertar la informacion en la structura.
            *** IMPORTANTE *** Es una structura especial para socket; sin_family, sin_port .... */
           
           // **** DATOS DE LA ESTRUCTURA CON LOS DATOS DE DESTINO
           direccion.sin_family=AF_INET; // AF_inet con el protocolo UDP (Información en el paso anterior)
           direccion.sin_port=htons(puerto); //Usamos HTONS para transformar el numero de puerto a uno entendible para el socket.
           direccion.sin_addr.s_addr=inet_addr(ip); // Y agregamos la IP
       
           /*
               Despues de crear el socket y la structura con los datos pertinentes,
               podemos conectar por fin al servidor, que en los sockets TCP se haría
               con CONNECT, pero en los UDP se hace bindeando el socket al cliente con
               BIND.
               
               Desglosado en partes, la línea siguiente se compone de:
               connect: Comando de conexión.
               sock: Define el socket que hemos creado en el paso 1
               struct sockaddr*:Aqui va la structura anteriormente paso 2 creada con todos los datos para conectar,ip,protocolo,puerto, (&dirrecion)
               sizeof: Utilizamos el operador sizeof para indicar la longuitud de la estructura
               Así es como queda la estructura final: connect(sock, (struct sockaddr*)&direccion,sizeof(direccion));
               
               A continuación definimos el socket:
               Bind: Crea la definición del socket que vamos a utilizar.
               Sock: Aqui va la structura anteriormente creada (struct sockaddr_in server;)con todos los datos del servidor,ip,protocolo,puerto) &server
               Sizeof: Utilizamos el operador sizeof para obtener la longuitud de la estructura
               Y el resultado es: bind(sock,(struct sockaddr *)&server,sizeof(server));
           */
             
           struct sockaddr_in me;
           memset(&me, 0, sizeof(me));
           me.sin_family = AF_INET;
           me.sin_addr.s_addr = htonl(INADDR_ANY);
           me.sin_port = htons(puerto);
       
           if (bind(sock, (struct sockaddr *)&me, sizeof(me))==-1)
               {
               puts("BIND FAILED - ERROR");
               }
           else
               {
               puts("BIND ASIGNADO CON EXITO");
               }
       
           /*
              Como las conexiones UDP no son orientadas a conexión, no podemos utilizar connect,
              ya que entraría en conflicto con bind. Así pues, lo dejamos comentado y listo para
              un posible socket TCP
           
              if(connect(sock,(struct sockaddr*)&direccion,sizeof(direccion))==-1)
                 {//conectamos al servidor aplicando el segundo filtro:
                 printf("ERROR AL CONECTAR");
                 getch();
                 exit(0);
                 }  
         
             //Confirmamos el éxito de la conexión
             printf("CONECTADO CORRECTAMENTE\n\n");
         
           */
         
           /*
           /////////////////////////////////////////////////////////////////////////////
           ||                                                                         ||
           ||                                                                         ||
           ||             DEFINICION DE LA CADENA DE DATOS A ENVIAR(buf)              ||
           ||                                                                         ||
           ||                                                                         ||
           /////////////////////////////////////////////////////////////////////////////
           */
         
           char total[531]; //Variable maestra en la que iremos introduciendo cada sección del paquete ArtNet Originalmente(531)
           char l_total; //Variable para introducir la suma de longitudes de los fragmentos del paquete
           char puntero; //Puntero para las operaciones de concatenación
           char cabecera[8]={65 , 114 , 116 , 45 , 78 , 101 , 116 , 0}; //Cabecera del paquete
           char opcode[2]={0, 80}; // OpCode (Originalmente 0 (El bit bajo primero) y 80)
           char version[2]={0 , 14}; //Indicador de la versión (Originalmente 0 y 14)
           char phisycal[1]={2}; //Subred. Originalmente 0
           char universo[2]={0 , 0}; //Define el universo en el que vamos a trabajar
           char lon_val[2]={2 , 0}; //Indice de la longitud de valores (Originalmente 2 y 0)  
           
           //Contamos el tamaño de cada cadena para obtener el tamaño final de la cadena de trabajo.
           const unsigned int array_sizes[] = {sizeof(cabecera) , sizeof(opcode) , sizeof(version) , sizeof(secuencia) , sizeof(phisycal) , sizeof(universo) , sizeof(lon_val) , sizeof(valores)};
         
           //Definimos los arrays y punteros para concatenar las cadenas
           char *arrays[] = {
                   cabecera,
                   opcode,
                   version,
                   (char*) secuencia,
                   phisycal,
                   universo,
                   lon_val,
                   (char*) valores};
             
           unsigned int i, bytes_copiados, total_bytes;
         
          //Realizamos la copia de las cadenas
          for(i = total_bytes = 0; i < sizeof(arrays) / sizeof(char *); total_bytes += array_sizes[i], i++);
         
          char *mensaje = (char *) malloc (total_bytes);
         
          //Aplicamos un filtro de error que indique un posible overflow
          if(!mensaje){
                       perror("Error al reservar memoria");
                       getch();
          }
          //Aplicamos la copia con la función memcpy
          for(i = bytes_copiados = 0; i < sizeof(array_sizes) / sizeof(int); bytes_copiados += array_sizes[i], i++)
          memcpy(mensaje + bytes_copiados, arrays[i], array_sizes[i]);
         
          //Mostramos el array de almacenaje (mensaje) e introducimos los datos en la cadena final
          cout<<"Estos son los datos enviados:"<<"\n\n";
          //Bucle de asignación de bytes al array de envio
          for(i = 0; i < total_bytes; i++)
               {
               //Mostramos en pantalla el byte
               printf("%d ", (unsigned char) mensaje[i]);
               //Copiamos ese mismo byte en el array de envio
               buf[i]=("%d ", (unsigned char) mensaje[i]);
               }
               
          cout<<"\nTotal de bytes:"<<total_bytes<<"\n";
       
          free(mensaje);
         
          /*Comprobamos que los datos se han transmitido correctamente al array de trabajo buf:
         
          cout<<"\n\nCOMPROBACION\n\n";
          for (i=0; i<531; i++)
              cout<<buf[i]<<" ";
         */
         
         /*
         /////////////////////////////////////////////////////////////////////////////
         ||                                                                         ||
         ||                                                                         ||
         ||          ENVIO DE DATOS AL DISPOSITIVO Y CIERRE DE CONEXIÓN             ||
         ||                                                                         ||
         ||                                                                         ||
         /////////////////////////////////////////////////////////////////////////////
       
         Ahora que ya estamos conectados al servidor,ya podemos enviarle informacion con la funcion (send).
         Este sería el caso de un socket TCP. Al ser un socket UDP, utilizamos la función sendto, que tiene
         una sintaxis distinta. Estos son sus elementos y las diferentes sintaxis de uso de las dos funciones:
           
               send: definicion del socket que creamos en el paso 1
               buf:variable con la informacion a enviar
               Sizeof: Utilizamos el operador sizeof para indicar la longuitud de la variable
               Flag: lo dejamos en 0
         El resultado final:
             
              PARA SEND:
                   send(sock,buf,sizeof(buf),0);
             
              PARA SENDTO:
                   (sock,buf,sizeof(buf),0,(struct sockaddr*)&receiver_addr,sizeof(receiver_addr));

         */
       
             if(sendto(sock,buf,sizeof(buf),0,(struct sockaddr*)&direccion,sizeof(direccion))==-1)
                {//Aplicamos el filtro de error de envio
                printf("ERROR ENVIANDO");
                getch();
                exit(0);
                }
             else
                 {//Confirmamos el éxito del envío
                  closesocket(sock);
                  //puts("\nMensaje enviado, pulsa una tecla para continuar");
                  //getch();
                 }
              };
          }
};

void doEtherRangeValue( long canal_1, long canal_2, long valor, XtraInfo * xtraInfo );
{
      int i;
      if ((canal_a<1) || (canal_a>512) || (canal_b>512) || (canal_a>canal_b) || (valor>255) || (valor<0))
         {
         system("cls");
         cout<<"ERROR - Numero de canal o valor indicado fuera de rango\nPulsa cualquier tecla para continuar...";
         getch();
         }
      else
          {
          //ARRAY DE VALORES DE CANALES
          int k;
          char valores[526];
          for (k=0; k<526; k++)
             {
             valores[k]=0;
             }
          //ARRAY DE SECUENCIA
          char secuencia[1];
          //Aplicamos el valor secuencia al punto CERO, ya que los arrays se definen con el entero de su tamaño, pero su primer valor es el 0, no el 1
          secuencia[0]=0;
          //Bucle de asignación de valores del rango
          for (i=(canal_a-1); i<(canal_b); i++)
              {
              valores[i]=valor;
              }
         
          /*
           /////////////////////////////////////////////////////////////////////////////
           ||                                                                         ||
           ||                                                                         ||
           ||                            *******CONEXION*******                       ||
           ||                                                                         ||
           ||                                                                         ||
           /////////////////////////////////////////////////////////////////////////////
           */
         
          system("cls");//Borramos la pantalla para eliminar las lineas mostradas en el menú

         /* Primero abrimos el socket Winsock. Tenemos varias opciones para definir
         el tipo de socket que vamos a crear:
               Familia del protocolo:
                       AF_INET: Para conexión con máquinas conectadas a Internet
                       AF-UNIX: Para conexion con máquinas LINUX
                       AF_NS:   Para conexión con máquinas XEROX
                       AF_CCITT:Para conexión con protocolos CCITT,X25...
               Tipo de socket:
                       SOCKET_STREAM: Para TCP
                       SOCKET_DGRAM:  Para UDP
                       SOCKET_RAW:    Para IP
               Protocolo:
                       PPROTO_TCP: Como dice su nombre, para protocolo TCP
                       PPROTO_UDP: Como dice su nombre, para protocolo UDP

         Así pues para una conexión UDP normal, el código sería: */

         WSADATA wsa; // Winshock
         int sock;//Descriptor del socket.
         struct sockaddr_in direccion; //Datos del servidor a conectar

         WSAStartup(MAKEWORD(2,0),&wsa);

         /* -Después creamos una structura (struct), en la que definiremos el tipo de
          -protocolo a utilizar para la conexion,
          -despues el puerto por el que deve conectarse nuestro cliente y
          -por último la ip a la que conectara nuestro cliente. */
         
         char buf[531];       // Tamaño del mensaje a enviar
         int puerto=6454;     // puerto del servidor a conectar
       
         if((sock=socket(AF_INET,SOCK_DGRAM,0))==-1 )
            {
            // Creamos el socket mientras creamos el primer filtro de error
            printf("PROBLEMA AL CREAR EL SOCKET");
            getch();
            exit(0);
            }
         else
           {
           printf("SOCKET CREADO CORRECTAMENTE\n\n");
           /* Ahora procedemos a insertar la informacion en la structura.
            *** IMPORTANTE *** Es una structura especial para socket; sin_family, sin_port .... */
           
           // **** DATOS DE LA ESTRUCTURA CON LOS DATOS DE DESTINO
           direccion.sin_family=AF_INET; // AF_inet con el protocolo UDP (Información en el paso anterior)
           direccion.sin_port=htons(puerto); //Usamos HTONS para transformar el numero de puerto a uno entendible para el socket.
           direccion.sin_addr.s_addr=inet_addr(ip); // Y agregamos la IP
       
           /*
               Despues de crear el socket y la structura con los datos pertinentes,
               podemos conectar por fin al servidor, que en los sockets TCP se haría
               con CONNECT, pero en los UDP se hace bindeando el socket al cliente con
               BIND.
               
               Desglosado en partes, la línea siguiente se compone de:
               connect: Comando de conexión.
               sock: Define el socket que hemos creado en el paso 1
               struct sockaddr*:Aqui va la structura anteriormente paso 2 creada con todos los datos para conectar,ip,protocolo,puerto, (&dirrecion)
               sizeof: Utilizamos el operador sizeof para indicar la longuitud de la estructura
               Así es como queda la estructura final: connect(sock, (struct sockaddr*)&direccion,sizeof(direccion));
               
               A continuación definimos el socket:
               Bind: Crea la definición del socket que vamos a utilizar.
               Sock: Aqui va la structura anteriormente creada (struct sockaddr_in server;)con todos los datos del servidor,ip,protocolo,puerto) &server
               Sizeof: Utilizamos el operador sizeof para obtener la longuitud de la estructura
               Y el resultado es: bind(sock,(struct sockaddr *)&server,sizeof(server));
           */
             
           struct sockaddr_in me;
           memset(&me, 0, sizeof(me));
           me.sin_family = AF_INET;
           me.sin_addr.s_addr = htonl(INADDR_ANY);
           me.sin_port = htons(puerto);
       
           if (bind(sock, (struct sockaddr *)&me, sizeof(me))==-1)
               {
               puts("BIND FAILED - ERROR");
               }
           else
               {
               puts("BIND ASIGNADO CON EXITO");
               }
       
           /*
              Como las conexiones UDP no son orientadas a conexión, no podemos utilizar connect,
              ya que entraría en conflicto con bind. Así pues, lo dejamos comentado y listo para
              un posible socket TCP
           
              if(connect(sock,(struct sockaddr*)&direccion,sizeof(direccion))==-1)
                 {//conectamos al servidor aplicando el segundo filtro:
                 printf("ERROR AL CONECTAR");
                 getch();
                 exit(0);
                 }  
         
             //Confirmamos el éxito de la conexión
             printf("CONECTADO CORRECTAMENTE\n\n");
         
           */
         
           /*
           /////////////////////////////////////////////////////////////////////////////
           ||                                                                         ||
           ||                                                                         ||
           ||             DEFINICION DE LA CADENA DE DATOS A ENVIAR(buf)              ||
           ||                                                                         ||
           ||                                                                         ||
           /////////////////////////////////////////////////////////////////////////////
           */
         
           char total[531]; //Variable maestra en la que iremos introduciendo cada sección del paquete ArtNet Originalmente(531)
           char l_total; //Variable para introducir la suma de longitudes de los fragmentos del paquete
           char puntero; //Puntero para las operaciones de concatenación
           char cabecera[8]={65 , 114 , 116 , 45 , 78 , 101 , 116 , 0}; //Cabecera del paquete
           char opcode[2]={0, 80}; // OpCode (Originalmente 0 (El bit bajo primero) y 80)
           char version[2]={0 , 14}; //Indicador de la versión (Originalmente 0 y 14)
           char phisycal[1]={2}; //Subred. Originalmente 0
           char universo[2]={0 , 0}; //Define el universo en el que vamos a trabajar
           char lon_val[2]={2 , 0}; //Indice de la longitud de valores (Originalmente 2 y 0)  
           
           //Contamos el tamaño de cada cadena para obtener el tamaño final de la cadena de trabajo.
           const unsigned int array_sizes[] = {sizeof(cabecera) , sizeof(opcode) , sizeof(version) , sizeof(secuencia) , sizeof(phisycal) , sizeof(universo) , sizeof(lon_val) , sizeof(valores)};
         
           //Definimos los arrays y punteros para concatenar las cadenas
           char *arrays[] = {
                   cabecera,
                   opcode,
                   version,
                   (char*) secuencia,
                   phisycal,
                   universo,
                   lon_val,
                   (char*) valores};
             
           unsigned int i, bytes_copiados, total_bytes;
         
          //Realizamos la copia de las cadenas
          for(i = total_bytes = 0; i < sizeof(arrays) / sizeof(char *); total_bytes += array_sizes[i], i++);
         
          char *mensaje = (char *) malloc (total_bytes);
         
          //Aplicamos un filtro de error que indique un posible overflow
          if(!mensaje){
                       perror("Error al reservar memoria");
                       getch();
          }
          //Aplicamos la copia con la función memcpy
          for(i = bytes_copiados = 0; i < sizeof(array_sizes) / sizeof(int); bytes_copiados += array_sizes[i], i++)
          memcpy(mensaje + bytes_copiados, arrays[i], array_sizes[i]);
         
          //Mostramos el array de almacenaje (mensaje) e introducimos los datos en la cadena final
          cout<<"Estos son los datos enviados:"<<"\n\n";
          //Bucle de asignación de bytes al array de envio
          for(i = 0; i < total_bytes; i++)
               {
               //Mostramos en pantalla el byte
               printf("%d ", (unsigned char) mensaje[i]);
               //Copiamos ese mismo byte en el array de envio
               buf[i]=("%d ", (unsigned char) mensaje[i]);
               }
               
          cout<<"\nTotal de bytes:"<<total_bytes<<"\n";
       
          free(mensaje);
         
          /*Comprobamos que los datos se han transmitido correctamente al array de trabajo buf:
         
          cout<<"\n\nCOMPROBACION\n\n";
          for (i=0; i<531; i++)
              cout<<buf[i]<<" ";
         */
         
         /*
         /////////////////////////////////////////////////////////////////////////////
         ||                                                                         ||
         ||                                                                         ||
         ||          ENVIO DE DATOS AL DISPOSITIVO Y CIERRE DE CONEXIÓN             ||
         ||                                                                         ||
         ||                                                                         ||
         /////////////////////////////////////////////////////////////////////////////
       
         Ahora que ya estamos conectados al servidor,ya podemos enviarle informacion con la funcion (send).
         Este sería el caso de un socket TCP. Al ser un socket UDP, utilizamos la función sendto, que tiene
         una sintaxis distinta. Estos son sus elementos y las diferentes sintaxis de uso de las dos funciones:
           
               send: definicion del socket que creamos en el paso 1
               buf:variable con la informacion a enviar
               Sizeof: Utilizamos el operador sizeof para indicar la longuitud de la variable
               Flag: lo dejamos en 0
         El resultado final:
             
              PARA SEND:
                   send(sock,buf,sizeof(buf),0);
             
              PARA SENDTO:
                   (sock,buf,sizeof(buf),0,(struct sockaddr*)&receiver_addr,sizeof(receiver_addr));

         */
       
             if(sendto(sock,buf,sizeof(buf),0,(struct sockaddr*)&direccion,sizeof(direccion))==-1)
                {//Aplicamos el filtro de error de envio
                printf("ERROR ENVIANDO");
                getch();
                exit(0);
                }
             else
                 {//Confirmamos el éxito del envío
                  closesocket(sock);
                  //puts("\nMensaje enviado, pulsa una tecla para continuar");
                  //getch();
                 }
              };
          }
      };


La parte de la conexión está repetida en las dos funciones porque estas han de ser "autónomas", pero no creo que eso tenga que ver con mi problema  

Gracias por la ayuda.

EI: juntando mensajes.

¿Nadie sabe cual puede ser el problema? Es extraño porque a veces avisa de "error" en cosas que parecen iguales (el uso de la variable valor dentro de una función, cuando valor ha sido declarado al declarar la función, hay sitios donde no da error y otros donde dice que valor no ha sido declarado, dentro de la función, un par de lineas más abajo de donde lo ha usado sin problema alguno!) o incluso en el uso de sentencias for, closesocket, system...

He intentado jugando con los espacios, añadiendo ; al final de los for (cosa que no es necesaria, al menos en Dev-C++) por descartar, pero los problemas siguen ahí. ¿Quizá esten mal declaradas las librerías? ¿La sintaxis es menos transigente en Visual Studio con el tema de espacios, o me falta algo importante?

Agradecería mucho un poco de ayuda, porque con este problema estoy muy estancado  

Gracias y un saludo.

[exel]

Solo he visto los errores lexicos y sintacticos:

void doEtherValue( long canal, long valor, XtraInfo * xtraInfo );
void doEtherRangeValue( long canal_1, long canal_2, long valor, XtraInfo * xtraInfo );
Supuestamente estas definiendo la funcion, no declarando un prototipo. Por lo tanto, los ; antes del { no deben estar


Las declaraciones de variables locales es al principio de cualquier bloque {...}


Linea 188... para ser mas legible, el ; del final es para no hacer nada en el cuerpo del ciclo for, pues deja un salto de linea entre ) y ;


Al final supuestamente estas cerrando el cuerpo de dos bifurcaciones else y la definicion de la funcion doEtherValue. Los ; que siguen a cada } no deben estar


Al final supuestamente estas cerrando el cuerpo de dos bifurcaciones else y la definicion de la funcion doEtherRangeValue. Los ; que siguen a cada } no deben estar


En la funcion doEtherRangeValue, ¿donde declaraste canal_a y canal_b?, quisas te refieres a canal_1 y canal_2 de los parametros de la funcion

No me he fijado en los nombres de las variables que usas, pero si no esta en los parametros de la funcion, no esta declarada dentro de la funcion, no esta declarada como global o no esta prototipada como extern, entonces no existe


¿Estas seguro que eso compila en Dev-C++?, de cualquier manera, los errores saltan a la vista.

Saludos

[VladisMSX1]

  No había visto el ; justo al final de la declaración de las funciones. El caso es que en mi código en Dev-C++ no está (sino, lógicamente, no compilaría) así que acabo de alucinar. No lo he visto sencillamente porque no esperaba que ahí hubiera un ; y ni me había fijado. Madre mía....

De un plumazo han desaparecido un montón de errores, entre ellos los que decían que las variables no estaban declaradas (de ahí que no le viera sentido)

Las variables de canal_a y canal_b están bien declaradas en mi código en Dev-C++. Lógicamente canal_1 debería ser canal_a.

En fin, fallazos de novato matao... creo que tenía tal dolor de cabeza que no he visto esos fallos aunque saltaban a la vista a ver si ahora la cosa funciona mejor.

Muchas gracias!