Problem z tablicą wskaźników do funkcji

Problem, który poniżej przedstawię mam w większym programie, ale żeby go przedstawić napisałem krótki kod. Chodzi o to, że otrzymuję błąd kompilacji kiedy w pętli wywołuje funkcje poprzez wskaźniki. Zaznaczyłem w deklaracji, że a jest argumentem domniemanym, wiec nie rozumiem skąd ten problem.

#include <iostream>
using namespace std;

bool fun1(double = 1);
bool fun2(double = 1);
bool fun3(double = 1);


void main()
{

	bool (*wsk[3])(double)={fun1, fun2, fun3};

	for(int i = 0; i < 3; i++)
	{
		(*wsk[i])();  // błąd kompilacji (too few arguments for call)
	}
 


	system("pause");

}

bool fun1(double a){  cout<<"\n\nWartosc zmiennej to: \n\n"<<a; return true; }
bool fun2(double a){  cout<<"\n\nWartosc zmiennej to: \n\n"<<a; return true; }
bool fun3(double a){  cout<<"\n\nWartosc zmiennej to: \n\n"<<a; return true; }

Nie rozumiem czemu cię to dziwi. Wskaźnik pokazuje na funkcję wywoływaną z jednym argumentem typu double i przy wywołaniu za jego pomocą wymaga podania tego argumentu. Kompilator nie jest jasnowidzem zeby wiedzieć ze ty akurat chcesz wywołać metodę która ma ten argument domniemany.

Przykładowo wsk[0] pokazuje na fun1 , a ona ma w deklaracji argument domniemany, więc (*wski powinno zaskoczyć.

Przy normalnym wywołaniu funkcji, która ma wszystkie argumenty domniemane możemy wywołać ją przecież tak fun1();

Wobec tego nie ma sensu stosować argumentów domniemanych w funkcjach które wywołujemy poprzez wskaźniki bo i tak trzeba ten argument podać w nawiasie, i na jedno wyjdzie czy argument jest domniemany czy nie.

Tak, tylko że deklarujesz wskaźnik, który ma pokazywać na funkcję wywoływaną z argumentem double, a potem odnosisz się do niego tak jakby miał pokazywać na funkcję, która argumentów nie ma. Wskaźnik nie wie co to za funk na którą pokazuje.

Ok, w takim razie nie ma korzyści ze stosowania argumentów domniemanych w funkcjach, które wywołujemy poprzez wskaźniki. Jeśli uważacie inaczej to proszę o przykład.

Nie nie ma, poniewaz argumenty domniemane "nie istnieją". Jest to tylko "skrót" na podstawie którego kompilator tłumaczy wywołanie na wywołanie pełnej N-argumentowej funkcji. Żądanie, aby byly one jakoś pamiętane i dostarczane świadczy, że nie rozumiesz czym one są, co potrafią, i/lub jak one działają.

Nie wiem czy wiesz, ale wartości domyślne argumentów nie sa częścia deklaracji/sygnatury funkcji, np. nie wyeksportujesz ich z dll'ki (chyba ze do .hpp wcisniesz, ale:) a i w dodatkumozna sobie je przedefiniowac w dowolnym miejscu:

int funkcja(int a, int b=5, int c=3){return a+b+c;}  // <-A

int test1()
{
    funkcja(1); // 1,5,3 - deklaracja A
}

int funkcja(int a, int b, int c=3);  // <-B

int test2()
{
    //funkcja(1); // blad kompilacji: redeklaracja B przeslonila A
    funkcja(1, 2); // 1,2,3 - deklaracja B
}

int test3()
{
    for(int i=0; i<5; ++i)
        if(i==3)
        {
             int funkcja(int a=1, int b=20, int c=0);  // <-C, deklaracje moga przeciez byc lokalne!
             funkcja(); // 1,20,0 - z deklaracji C
        }
    // funkcja(); // blad kompilacji - deklaracja C wyszla poza scope
    funkcja(2,4); // 2,4,3 - deklaracja "B"
}

nie gwarantuje, że kod sie skompiluje, pisałem na biegu, ale tego typu konstrukcje sa poprawne. Argumenty domyslne sa chwilowe i ulotne wg. scope'a!

Skad wiec biedny kompilator i biedny wskaznik ma wiedziec, jakie sa te domyslne argumenty? wskaznik ma stala wielkosc, np. 4 bajty, zeby wskaznik pamietal LISTE aktualnych domyslnych argumentow, moglby wazyc na przyklad 200 bajtow bo bylo pol setki parametrow.

Wartosci domyslne na bok, nawet przy argumentach ktore sa WBUDOWANE w język, jak np. wartosc this wszystkich metod, takie "tricki" nie przechodza. Dlatego wlasnie wskaznik na metode to INNY TYP niz wskaznik na funkcje -- zeby w TYPIE/SYGNATURZE byla informacja ze ten-jeszcze-parametr-wiecej proszę..