Hola!..

Estoy practicando Unreal y QT Creator, en ambos he visto esta sintaxis:

 
void unaFuncionCualquiera(){
 
     unaClase.unMetodo(&ClaseA::unaFuncionB);  //este argumento..
 
}
 
 
void ClaseA::unaFuncionB(){
     //hacer algo
}
 

En Unreal se manipulan los controles de esta forma.
En QT se conecta un botón con una función...

Entiendo el efecto que tiene, pero que tipo de parámetro es?,, como se denomina este tipo de parámetros?



Saludos y gracias.

 
#include<iostream>
#include<conio.h>
#include<stdlib.h>
#include <stdio.h>
 using namespace std;
 
 
 int main(){
    while(1){
 
       int n, sumaP=0, sumaI=0, sumaM=0, opcion;
 
      cout<<"Digite un numero"<<endl;cin>>n;
      cout << "\t1 .Suma de Pares " << endl;
      cout<<"\t2 .Suma de Impares "<<endl;
      cout<<"\t3 .Suma de Multiplos de 5 "<<endl;
 
      /*cout<<"\t5. Retroceder"<<endl;*/
 
      cout<<"\t4 .Salir\nOpcion :"<<endl;
      cin>>opcion;
 
      for (int i=1; i<=n;i++){
 
 
          switch (opcion){
 
          case 1 :
                 system("cls");
                 if (i %2==0 ){
 
                     sumaP=sumaP+i;
                     cout<<"La suma de pares es: "<<sumaP<<endl;
 
                 }
                 break;
          case 2 :
                  system("cls");
                  if (i%3==0){
                       sumaI=sumaI + i;
                       cout<<"La suma de impares es: "<<sumaI<<endl;
 
                  }
 
                  break;
 
           case 3 :
                  system("cls");
                  if (i%5==0){
                       sumaM=sumaM + i;
                       cout<<"La suma de multiplos de 5 es: "<<sumaM<<endl;
 
                  }
                  break;
 
           case 4:
                  cout<<"Salir\n";
                  exit(0);
      }
 
      cout<<("Presione un tecla para regresar al Menu Principal.\n");
      getch();
    }
 
 
return 0;
 
}
 
 

Hola, con la sintaxis es mas fácil que puedan ayudarte..

Creo entender, ustedes me corrigen...

tendría que llamar a una función con el punto si esta siendo referenciada  por una variable común y corriente..

o con el operador -> si fuera referenciada por un puntero..
pero Run() al ser estatica, no existe una instancia a ella, por eso no se usa ni punto ni ->, directamente el operador ::



saludos y gracias.

Gracias por las aclaraciones

Si, me he dado cuenta que es un tipo manejado de cpp.

Entonces Application es una clase, pero, porque se llama a la función estática Run() de esa forma?

Application::Run();

Pense que los métodos se llamaban solo de dos formas:

Appication.Run()

o

Application->Run();

Hola!

Entiendo que el operador de resolución de ámbito :: conecta un namespace con otro namespace o con una clase o con un método que esté dentro de un namespace específico... sin embargo, estoy viendo esto en Visual C++ y me asaltó la duda:


Entiendo que System es un namespace, pero que serían Windows, Forms, Application y Run en este caso?

No estoy seguro pero me da la idea de que desde System hasta Application son namespace y Run es una función...  pero quisiera estar seguro.

Gracias saludos.

Muchas gracias ambos, me ha quedado claro... 

Antes le tenia terror a C++, pero con vosotros he aprendido bastante, y creo que ese miedo que le tenia realmente no tenia sentido, se programar en C#, pero creo que quedare definitivamente con C++, no me importa estar escribiendo mas, se pasa muy bien.

Gracias nuevamente.

Amigo, le dejo aquí su código formateado para que lo ayuden mejor..

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
 
 void mostrar_menu() {
     int i;
system("color 02");
system("pause");
system("cls");
system("color 07");
      printf("\n\nMenú:\n=====\n\n");
      printf("Escoge una opción:\n ");
      char a [][60]={"","|***Añadir***|","|****Mostrar****|","|*****Eliminar cliente*****|","|*****Salir*****|"};
 
  for(i=1;i<5;i++){
  printf("%d-%s\n",i,a);
 }
 }
 
 
struct registro{
 int numero;
 char   nombre[30];
 char   genero[20];
 float paga;
};
struct registro emp;
 
FILE *fd;
 
 void anadir()
{
    char otro;
    fd=fopen("cliente.txt","a");
   if(fd==NULL)
   {
      printf("El archivo no se puede abrir ....\n\t\t\t");
      system("pause");
   }
   else
   {
       do{
            system("cls");;
            printf("\t\t\tREGISTRAR  \n");
            printf("\n\t\tNumero  : ");   scanf("%d",&emp.numero);   fflush(stdin);
            printf("\t\tNombre  : ");   gets(emp.nombre);          fflush(stdin);
            printf("\t\tGenero: ");   gets(emp.genero);          fflush(stdin);
            printf("\t\tPaga  $");    scanf("%f",&emp.paga);   fflush(stdin);
            fprintf(fd,"%d  %s %f \n",emp.numero,emp.nombre,emp.paga);
            printf("\n\t\tDesea registrar otro S/N :");
            scanf("%s",&otro);
       }while ( otro =='S' ||  otro =='s' ) ;
        fclose(fd);
     }
}
 void mostrar_lista(){
     system("cls");
    fd=fopen("cliente.txt","r");
    if(fd==NULL)
    {
      printf("\t\tEl archivo no se puede abrir ....\n\t\t\t");
      system("pause");
    }
    else
    {
        printf("\t\t     R E P O R T E    D E    C L I E N T E S  ");
        printf("\n\n\t\tNumero \tNombre \tGenero \t Paga \n");
        printf("\t\t______ \t______ \t _____ \t _____ \n");
        fscanf(fd,"%d",&emp.numero);
        while (! feof(fd))
        {
           fscanf(fd,"%s",&emp.nombre);
           fscanf(fd,"%s",&emp.genero);
           fscanf(fd,"%f",&emp.paga);
           printf("\t\t%d\t%s\t%s\t$%.2f \n",emp.numero, emp.nombre , emp.genero ,emp.paga);
           fscanf(fd,"%d",&emp.numero);
        }
        printf("\n\t\t");
        system("pause");
    }
 }
 
void elimina_lista(){
    int buscar;
    FILE *aux;
    int bandera=0;
       system("cls");
       printf("\t\tELIMINAR CLIENTE\n  ");
       printf("\t\tNumero de cliente : ");
       scanf("%d",&buscar);
       fd=fopen("cliente.txt","r");
       aux=fopen("auxiliar.txt","w");
       if(fd==NULL)
        {
          printf("\n       El archivo no se puede abrir, primero debe crearlo");
          system("pause");
         }
         else
         {
            bandera=0;
             fscanf(fd,"%d",&emp.numero);
            while (!feof(fd) )
            {
                  fscanf(fd,"%s",&emp.nombre);
                  fscanf(fd,"%s",&emp.genero);
                  fscanf(fd,"%f",&emp.paga);
                  if( buscar== emp.numero)
                  {
                    printf("\t\tNombre              %s\n",emp.nombre);
                    printf("\t\tGenero              %s\n",emp.genero);
                    printf("\t\tPaga             $%f\n",emp.paga);
                    printf(" \n\t\tEl cliente sera eliminado y no lo recuperara.....\n\t\t");
                    system("pause");
                    bandera=1;
                  }
                  else
                  {
                    fprintf(aux,"%d %s %s %f\n",emp.numero, emp.nombre, emp.genero, emp.paga);
                  }
                  fscanf(fd,"%d",&emp.numero);
 
            }
            if (bandera==0){
                    printf("\nEl cliente no existe\n");
            }
            fclose(fd);
            fclose(aux);
            remove("cliente.txt");
            rename("auxiliar.txt","cliente.txt");
         }
 
}
 
 
 
int main () {
     int opc,  x=0, num, z;
     do {
         mostrar_menu();
         opc = getch();
             switch ( opc ) {
                case '1': anadir();
                       break;
                case '2':  printf("Lista de clientes\n");
                mostrar_lista(emp);
                     fclose(fd);
 
                        break;
                case '3':printf("Eliminar registro \n");
                  elimina_lista();
                        break;
                case '4': exit( 1 ); break;
                default: printf( "Opcion no valida\n" );
                         break;
             }
     } while (opc!='4');
 
     return 0;
 
 }
 

Muy buenas..

Estoy siguiendo unos tutoriales de Unreal Engine y me tope con algo que no habia visto:

float CurrentScale = OurVisibleComponent->GetComponentScale().X;
 

Mi duda está precisamente en la sintaxis de GetComponentScale().X;

Es primera vez que veo esa terminación  ().X;

Cual sería el prototipo de esa clase de funcion ?

Gracias de antemano.

Ya veo, entonces es una practica para que el compilador no se confunda (digo no se confunda, en vez de decir que no encuentra ambiguo el código).. asi con la palabra class diferencia qué es un tipo y que es una variable..

gracias por las respuestas..

Buenas ..

Cual es el objetivo de la siguiente sintaxis ?

#include "ActorY"
 
class Actor{
 
public:
 
     class ActorY _actorY;     //Que pinta class aqui?
 
};
 
 

Saludos y gracias.