Koja je razlika izmedju prototipa i definicije funkcije u C++?

[rockclimber]

Koja je razlika izmedju prototipa i definicije funkcije u C++ i koja je prednost koriscenja prototipa?

 

[bequick]

Nisam siguran da li si na ovo mislio al ajde:

znaci prototip kad kazes npr.

void radiNesto();

Dok definicija funkcije, zapravo definisemo sta radi

void radiNesto()
{
cout<<"Radi Nesto"<<endl;
}

Znaci u prototipu ne definises sta radi ta funkcija vec samo stavljas komplajeru do znanja da takva funkcija postoji.

Evo primer.

#include<iostream>

int BaciPet()
{ 
return 5;
}

int main()
{ 
int n = BaciPet();
std::cout<<n;

return 0;
}

I sad ovo sve radi normalno ali sta ako hoces da funkciju BaciPet() definises posle main-a, onda komplajer nezna da ta funkcija zapravo postoji i onda na pocetku napisemo prototip funkcije, evo i kod:

#include<iostream>

int BaciPet();  //prototip te funkcije

int main()
{ 
int n = BaciPet();  
std::cout<<n;

return 0;
}

//ali tek ovde je definisana

int BaciPet()
{ 
return 5;
}

Posle kad pocnes da koristis i OO stvari u c++, videc da naprimer u header fajlovima .h pravis prototipe a u .cpp definises

 

[2paca.zwaka]

Mislim da ti pitanje nije ok ......

 

[programmer^]

Ako je bequick u pravu, onda ti je bolje da koristis definiciju funkcije, a ne prototip, mada ja sad prvi put cujem za to Mislim koristio sam i ja funkcije do sada nego nikad nisam cuo za ovaj prototip

 

[Миша]

Прототип и дефиницја нису дуални. Прототип ти омогућава да у неком делу кода означиш да нека функција постоји (ко зна где...):

char* dupliraj_string(char*);

Док дефиниција служи да се та функција и напише:

char* dupliraj_string(char* str)
{
  // ...
}

Најпростија примена им је једноставна прегледност у оквиру једног фајла. Неки *.c/*.cpp фајл се сматра читљивијим уколико на његовом почетку може да се види списак функција које садржи. А нанизани прототипи функција управо пружају ову форму.

Сложенији случај се јавља када желиш да напишеш библиотеку. Рецимо да ти овај механизам допушта да све своје дефиниције држиш у маси *.c/*.cpp фајлова, а прототипе у једном или неколико *.h фајлова. Када компајлираш библиотеку, она постаје један фајл којег твој корисник може да повеже за свој пројекат. Све што му онда још фали су -- прототипи, управо смештени у *.h фајловима које му достављаш одвојено.

Има и других различито мотивисаних примена. Види:

http://www.learncpp.com/cpp-tutorial/19-header-files/
http://www.fredosaurus.com/notes-cpp/basics/multiple-files.html
http://stackoverflow.com/questions/6358512/header-files-in-c
http://www.gpwiki.org/index.php/Programming_Techniques:C/CPP_Header_File_Convention

 

[falco]

Poruke su prebacene u novu temu. Ako ne valja naziv teme, slobodno dajte predlog pa cu da preimenujem.

 

[2paca.zwaka]

Prototip pises ispred main samo da bi se ta funkcija laicki receno napravila prije main-a
recimo

#include <cstdlib>
#include <iostream>

int main(){
     std::cout << sab(1,4);
     std::system("PAUSE");
     return 0;
}

int sab(int a,int b){
      return a+b;
}

ovo ti se nece isvrsiti koliko ja znam......greska je koriscenje nedefinisane funkcije ili prom. msm nisam siguran

al ovo

#include <cstdlib>
#include <iostream>

in sab(int a,int b);

int main(){
     std::cout << sab(1,4);
     std::system("PAUSE");
     return 0;
}

int sab(int a,int b){
      return a+b;
}

ce uraditi posao ........nisam koristio izraz prototip vec deklaracija( msm da je isto kad se o ovome govori )

eto nadam se da si skontao

 

[Миша]

#include <cstdlib>
#include <iostream>

int main(){
     std::cout << sab(1,4);
     std::system("PAUSE");
     return 0;
}

int sab(int a,int b){
      return a+b;
}

То, наравно, не ради. Али зато и ово ради:

#include <cstdlib>
#include <iostream>

int sab(int a,int b){
      return a+b;
}

int main(){
     std::cout << sab(1,4);
     std::system("PAUSE");
     return 0;
}

Већ сам навео да се у том случају може употребити прототип како би се код учинио читљивијим:

Најпростија примена им је једноставна прегледност у оквиру једног фајла. Неки *.c/*.cpp фајл се сматра читљивијим уколико на његовом почетку може да се види списак функција које садржи. А нанизани прототипи функција управо пружају ову форму.

Али нисам навео и остале тривијалне примене. На пример, уколико је потребно да две класе укључују елементе оне друге:

#include <vector>
using namespace std;

class Parent;

class Child {
	Parent* p;
	public:
		Child():
		p(0)
		{}
		void setParent(Parent*p)
		{ this->p = p; }
};

class Parent {
	vector<Child*> children;
	public:
		Parent()
		{}
		void addChild(Child*c)
		{
			if(c)
			{
				c->setParent(this);
				children.push_back(c);
			}
		}
};

Четврта линија "class Parent;" је линија која у том коду омогућава да се у класи Child направи показивач на Parent, али то још увек није свеукупна моћ декларација (прототипова). Исте ове класе можеш да поделиш у фајлове:

Parent.cpp, Parent.h
Child.cpp, Child.h

И онда у њима можеш да држиш само податке о њима. Нпр.

Parent.h

#ifndef INC_PARENT
#define INC_PARENT

#include <vector>
class Child;

class Parent {
	std::vector<Child*> children;
	public:
		Parent();
		void addChild(Child*);
};

#endif

Parent.cpp

#include "Parent.h"
#include "Child.h"

Parent::Parent()
{}

void Parent::addChild(Child*c)
{
	if(c)
	{
		c->setParent(this);
		children.push_back(c);
	}
}

Child.h

#ifndef INC_CHILD
#define INC_CHILD

class Parent;

class Child {
	Parent* p;
	public:
		Child();
		void setParent(Parent*);
};

#endif

Child.cpp

#include "Child.h"

Child::Child():
p(0)
{}

void Child::setParent(Parent*p)
{ this->p = p; }

Онда се може направити опште заглавље:
myhead.h

#ifndef INC_MYHEAD
#define INC_MYHEAD
#include "Parent.h"
#include "Child.h"
#endif

Па би main изгледао отприлике овако:

#include "myhead.h"

int main()
{
	Parent p;
	Child a,b,c;
	
	p.addChild(&a);
	p.addChild(&b);
	p.addChild(&c);
	
	return 0;
}

Предност овакве организације пројекта је што држање свих класа у једном фајлу значи компајлирање свих тих класа при сваком компајлирању пројекта. На већим пројектима би ово (беспотребно) узимало доста времена. Уколико се ове класе пак поделе у више *.cpp фајлова, а њихови прототипови се "шерују" путем *.h фајлова, при компајлирању се поново компајлирају само директно или индиректно ажуриране компоненте, што штеди време.

Слично важи и за просте функције.

 

[programmer^]

Zar nije lakse samo da napises definiciju kad ti je potrebna???

 

[Миша]

Дефиниши "лакше" и "потребно".

 

[2paca.zwaka]

Miso svaka cast

 

[rockclimber]

Hvala puno na iscrpnom objasnjenju! Tek sam poceo da ucim C++ i veoma sam radoznao. Sad znam kome da se obratim kad negdje zapne.

 

[bequick]

Ako je bequick u pravu

Ti sumljas u mene

Cisto da nebude zabune, znaci napisatiti prototip nije isto sto i definisati funkciju naravno da svaka funkcija mora biti i definisana jer ako nije there's no fu** sense.
Znaci prototip kad napisemo komplajer samo stavljamo do znanja da takva funkcija postoji i da cemo je kasnije u kodu definisati.

 

[bud@]

Makro definicija potiche od C-a, upravlja shta i kako treba da se kompajlira.
Prototip funkcije omoguc'uju pristup, nechem ili vec' kompiliranom (od nekog drugog) ili nechemu shto tek treba da se kompajlira jer tome treba isto neshto, shto recimo josh nije kompilirano ili zavisi od neke definicije.
Virtualne funkcije su C++, veoma slichne, svemu gore navedenom, omoguc'uje kasnije povezivanje ali izmedju klasa.
Jer jedna klasa moze da ima i po nekoliko podklasa, bazichnih klaza, koje su isto mozzda virtualne.

 

[DarkSoul]

Ovo se zapravo proteže i kroz kompajler i linker, ali da sad ne komplikujemo... vidim da su kolege forumaši baš fino objasnili...