Definicja wskaźnika do funkcji

0

Czy da się napisać ( a jeśli tak to proszę przykład ) bez użycia definicji typu, albo definicji
bezpośrednio w klasie, definicję funkcji zwracającej wskźnik do funkcji? przykład :

class KlasaA
{
    int Funkcja( char * ){ cout << "Funkcja" ;};
    int (KlasaA::*FunkcjaWskaznik( int cos ))( char * ); // to ta funkcja o którą mi chodzi
}

int  (KlasaA::*FunkcjaWskaznik( int cos ))( char * )// jak napisać zeby to bylło traktowane jako definicja
{                                                    // metody klasy 'KlasaA' ???
     cout << "Funkcja zwracajaca wskaznik";
     return &KlasaA::Funkcja;
}
0

typedef int (FunkcjaWskaznik)(Parametry funkcji);

0

bez definicji typu raczej sie nie da

0

jak to sie nie da? przykład:

//definicja funkcji zwracającej wskźnik do funkcji
#include<iostream>
using namespace std;
float func2(int d){cout<<d;return 3.4;};
float (*(func1)(char a))(int){cout<<a<<endl;return *func2;};//tutaj
int main(){
}
0

@and91
Ja tutaj widze typ.

@Rage24
Co Ty chcesz osiągnąć?

0
and91 napisał(a)

jak to sie nie da? przykład:

//definicja funkcji zwracającej wskźnik do funkcji
#include<iostream>
using namespace std;
float func2(int d){cout<<d;return 3.4;};
float (*(func1)(char a))(int){cout<<a<<endl;return *func2;};//tutaj
int main(){
}

o tym nie pomyslalem ;-)

0

O coś takiego Ci chodzi?

#include <windows.h>
#ifdef __BORLANDC__
   #pragma argsused
#endif
#include <fstream.h>
//================================================================
class KLASA{
 public:

   int fA(int a){
      return a*a;
   }

   int fB(int a){
      return a*a*a;
   }

   int (KLASA::*wskFW)(int);

   int (KLASA::* (FSUPER)(int ktora))(int){
      if(ktora == 1) return &KLASA::fA;
      return &KLASA::fB;
   }
};
int (KLASA::*wskF)(int);
//================================================================
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){
   switch(message){
      case WM_DESTROY:
         PostQuitMessage(0);
      return 0;

      default:
         return DefWindowProc(hWnd, message, wParam, lParam);
   }
}
//================================================================

char t[100];
//================================================================
int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE, LPSTR, int){

   KLASA kX;
   wskF = kX.FSUPER(1);
   int resA = (kX.*wskF)(2);

   wskF = kX.FSUPER(2);
   int resB = (kX.*wskF)(2);

   sprintf(t, "%d %d", resA, resB);
   MessageBox(0, t, "wynik", MB_OK);

   //////////////////////////////
   kX.wskFW = kX.FSUPER(1);
   resA = (kX.*(kX.wskFW))(2);

   kX.wskFW = kX.FSUPER(2);
   resB = (kX.*(kX.wskFW))(2);


   sprintf(t, "%d %d", resA, resB);
   MessageBox(0, t, "wynik", MB_OK);


   return 0;
}
//================================================================
0

interesuje mnie tylko czy składnia umożliwia zapisanie definicji funkcji poza wnetrzem klasy, bez definiowania jej we wnątrz, jakj tu:

class KlasaA
{
    int Funkcja( char * ){ cout << "Funkcja" ;};
    int (KlasaA::*FunkcjaWskaznik( int cos ))( char * )
   {  cout << "Funkcja zwracajaca wskaznik";
       return &KlasaA::Funkcja; }
}

albo z urzyciem 'typedef':


class KlasaA;

typedef int (KlasaA::*P2Func)( char * );

 class KlasaA
{
    int Funkcja( char * ){ cout << "Funkcja" ;};
   P2Func FunkcjaWskaznik( int cos );
}

P2Func KlasaA::FunkcjaWskaznik( int cos )  // definiuje funkcje 'KlasaA::' informuje kompilator że to
{                                          // jest definicja metody klasy 
       cout << "Funkcja zwracajaca wskaznik";
       return &KlasaA::Funkcja;
}

ale jak napisać to samo bez zdefiiowanego typu wskaźnika przez urzycie 'typedef'?


int (KlasaA::*FunkcjaWskaźnik( int cos ))( char * ) // musi być dodane informacja że to jest metoda 
{                                         // ale jak to ma wyglądać
       cout << "Funkcja zwracajaca wskaznik";
       return &KlasaA::Funkcja;
}

inaczej kompilator traktuje powyższy fragment jako definicje funkcji globalnej zwracającej wskaźnik do
metdy należącej do 'KlasaA'. W gruncie rzeczy z definicją typu jest przejżyściej, jestem tylko ciekawy czy da sie to zrobić za pomocą jednego wyrażenia.

0

czy ktoś wie jak dziala metoda CopyRect i co to jest w nawiasie i do czego co sluzy

0

No to chyba o to Ci chodzi:

class KLASA{
 public:

   int fA(int a){
      return a*a;
   }

   int fB(int a){
      return a*a*a;
   }

   int (KLASA::*wskFW)(int);

   //int (KLASA::* (FSUPER)(int ktora))(int){   // wewnatrz
   //   if(ktora == 1) return &KLASA::fA;
   //   return &KLASA::fB;
   //}
   int (KLASA::* (FSUPER)(int ktora))(int);
};
// na zewnatrz klasy
int (KLASA::* (KLASA::FSUPER)(int ktora))(int){
   if(ktora == 1) return &KLASA::fA;
   return &KLASA::fB;
}

A jak nie to chyba nie czaje o co cho

pixel10061988: chyba chciałeś założyć nowy post

0

No tak, ale to jest nadal wskaźnik na konkretny typ (w tym przypadku na funkcję zwracającą int i przyjmującą jako parametr int) i to jest całkiem normalny zapis, bo wskaźnik można przecież ustawić na kilka z nich. Natomiast bez typu to nie przejdzie, więc @Rage24 odpowiedź na towje pytanie brzmi: nie (chyba że nie wiem o co Ci tak naprawde chodzi :( ).

0

Wielkie dzięki -=mAkAbrAs=-. Chodziło mi o tą linijkę :

int (KLASA::* (KLASA::FSUPER)(int ktora)))(int)

1 użytkowników online, w tym zalogowanych: 0, gości: 1