Functie declaratie binnen of buiten de klas

Ik ben een JAVA ontwikkelaar die is bezig met het leren van C++, maar ik weet niet echt wat het beste is voor de standaard functie declaraties.

In de klas:

class Clazz
{
 public:
    void Fun1()
    {
        //do something
    }
}

Of buiten:

class Clazz
{
public:
    void Fun1();
}

Clazz::Fun1(){
    //Do something
}

Ik heb het gevoel dat de tweede kan worden minder leesbaar is…

  • Er zijn eigenlijk 3 opties hier. Je tweede voorbeeld zou kunnen zijn de functie-definitie in het header-bestand (maar nog steeds niet uitgelijnd), of in een aparte .cpp bestand.
  • Dit is een vraag kunnen je helpen begrijpen.
  • Gewoon een opmerking: verklaring is altijd in de klas, maar definitie is binnen of buiten. De vraag titel en het lichaam moeten worden onderworpen aan de s/verklaring/definitie/ me niet geloven? stackoverflow.com/q/1410563/1143274
  • Functie-definities in klasse moet worden vermeden. Zij worden geacht impliciet inline.
InformationsquelleAutor JohnJohnGa | 2012-01-31

 

7 Replies
  1. 48

    C++ is object georiënteerd, in de zin dat het ondersteunt het object georiënteerde paradigma voor de ontwikkeling van software.

    Echter, anders dan in Java, C++ dwingt je niet om de groep functie-definities in klassen: de standaard C++ manier voor het verklaren van een functie van alleen het declareren van een functie, zonder enige klasse.

    Als u in plaats daarvan praten over de methode verklaring/definitie dan de standaard manier is om gewoon de verklaring in een include-bestand (gewoonlijk met de naam .h of .hpp) en de definitie in een aparte uitvoering bestand (gewoonlijk met de naam .cpp of .cxx). Akkoord, dit is inderdaad wat lastig en vereist enige duplicatie, maar het is hoe de taal is ontworpen.

    Voor snelle experimenten en één bestand projecten die iets zou werken… maar voor grotere projecten is deze scheiding is iets wat praktisch nodig is.

    Opmerking: Zelfs als u weet Java, C++ is een volledig andere taal… en het is een taal die niet kunnen worden geleerd door te experimenteren. De reden is dat het een nogal complexe taal met veel asymmetrie en schijnbaar onlogische keuzes, en nog belangrijker, wanneer u een fout maakt, er zijn geen ‘runtime-fout engelen” om u te redden, zoals in Java… maar er zijn in plaats van “undefined gedrag daemons”.

    De enige redelijke manier om te leren van C++ is door het lezen van ” het maakt niet uit hoe slim je bent er is geen manier u kunt raden wat het comité besloten (eigenlijk slim is soms nog een probleem, want het juiste antwoord is onlogisch en is een gevolg van het historisch erfgoed.)

    Kies een goed boek of twee en ze te lezen van kaft tot kaft.

    • Als iemand komt uit Java en vraagt om hulp op C++, wat doet het dan zeg hem als je zegt dat “de taal die je kent is geobsedeerd door iets”? Hij hoeft niet een vergelijking met andere talen, zodat deze vertelt hem vrijwel niets. Beter dan het gebruik van een stronly emotioneel connotated woord zo geobsedeerd, dat betekent niet dat het OP veel, je zou kunnen overwegen slechts het verlaten van deze deel uit. Bovendien, wat is de context van “het gebruik van een klasse voor alles”? In Java kunt u niet gebruik maken van een klasse met een methode. U hoeft geen gebruik van een klasse voor een variabele. U hoeft geen gebruik van een klasse naar een bestand..Dus wat is “alles” hier? Schelden?
    • Verwijderd dat een deel omdat blijkbaar beledigd u (geen idee waarom). Zeker, ik ben niet gek, over Java, omdat ik eigenlijk niet gebruik maken van Java helemaal niet, ik dacht gewoon op de tijd die OOP als Object Geobsedeerd Programmering was een leuke grap, terwijl het blijkbaar niet. Ik heb een Java 1.1 certified programmer, maar besloot toen dat, tenzij gedwongen om een bepaalde reden, ik zal geen gebruik maken van die “programmeertaal” en zo ver ik er in geslaagd om het te voorkomen.
    • Bedankt, ik denk dat het leest veel beter nu. Sorry als ik het geluid beledigd. Ik zal proberen om meer positief te zijn de volgende keer.
    • Geeft geen antwoord op de vraag
    • wat is het deel van het derde lid, dat is niet duidelijk voor u?
    • “ongedefinieerd gedrag deamons” – ik denk dat ik liever nasale deamons

  2. 20

    De eerste bepaalt uw functie als lid van een inline-functie, terwijl de tweede niet. De definitie van de functie in dit geval bevindt zich in de header zelf.

    De tweede uitvoering zou de definitie van de functie in het cpp-bestand.

    Zowel semantisch anders en het is niet alleen een kwestie van stijl.

    • cplusplus.com/doc/tutorial/classes geeft hetzelfde antwoord: “Het enige verschil tussen het definiëren van een lid van de klas functie volledig in zijn klasse, of alleen het prototype en later zijn definitie, is dat in het eerste geval zal de functie automatisch worden beschouwd als een in line functie lid door de compiler, terwijl in het tweede geval zal het een normale (niet-inline) lid van de klas functie, die in feite veronderstelt geen verschil in gedrag.”
  3. 15

    Functie definitie beter buiten de klas. Op die manier zijn uw code kunt veilig blijven als dat nodig is. Het header-bestand moet geven verklaringen.

    Stel dat iemand wil om je code te gebruiken, u kunt slechts hem .h-bestand en .obj bestand (verkregen na compilatie) van de klasse. Hij heeft geen behoefte aan .cpp bestand om je code te gebruiken.

    Op die manier uw uitvoering is niet zichtbaar voor iedereen anders.

  4. 10

    “In de klas” (I) methode doet hetzelfde als de “buiten de klas” (O) – methode.

    Echter, (I) kan worden gebruikt als een klasse wordt alleen gebruikt in een bestand (in een .cpp-bestand). (O) wordt gebruikt wanneer het in de header-bestand. cpp-bestanden worden altijd samengesteld. Header bestanden worden gecompileerd wanneer u gebruik #include ” – header.h”.

    Als u (I) in een header-bestand, de functie (“Fun1) zal worden verklaard, elke keer als je onder #include” – header.h”. Dit kan leiden tot het declareren van dezelfde functie meerdere keren. Dit is moeilijker te compileren, en kan zelfs tot fouten leiden.

    Voorbeeld voor een correct gebruik:

    File1: “Clazz.h”

    //This file sets up the class with a prototype body. 
    
    class Clazz
    {
    public:
        void Fun1();//This is a Fun1 Prototype. 
    };

    File2: “Clazz.cpp”

    #include "Clazz.h" 
    //this file gives Fun1() (prototyped in the header) a body once.
    
    void Clazz::Fun1()
    {
        //Do stuff...
    }

    File3: “UseClazz.cpp”

    #include "Clazz.h" 
    //This file uses Fun1() but does not care where Fun1 was given a body. 
    
    class MyClazz;
    MyClazz.Fun1();//This does Fun1, as prototyped in the header.

    File4: “AlsoUseClazz.cpp”

    #include "Clazz.h" 
    //This file uses Fun1() but does not care where Fun1 was given a body. 
    
    class MyClazz2;
    MyClazz2.Fun1();//This does Fun1, as prototyped in the header. 

    File5: “DoNotUseClazzHeader.cpp”

    //here we do not include Clazz.h. So this is another scope. 
    class Clazz
    {
    public:
        void Fun1()
        {
             //Do something else...
        }
    };
    
    class MyClazz; //this is a totally different thing. 
    MyClazz.Fun1(); //this does something else. 
  5. 3

    Lid-functies kunnen worden gedefinieerd in de klasse definitie of afzonderlijk met behulp van scope resolution operator, ::. Het definiëren van een lid functie binnen de klasse definitie verklaart de functie inline, zelfs als u geen gebruik van de inline-consultant. Dus ofwel u kunt definiëren Volume() functie zoals hieronder:

    class Box
    {
      public:
    
         double length;
         double breadth;    
         double height;     
    
         double getVolume(void)
         {
            return length * breadth * height;
         }
    };

    Als je wilt kun je definiëren dezelfde functie buiten de klas met behulp van scope resolution operator :: als volgt

    double Box::getVolume(void)
    {
       return length * breadth * height;
    }

    Hier alleen belangrijk punt is dat je zou hebben om een klasse naam, net vóór :: operator. Een lid van de functie worden aangeroepen met behulp van een operator punt (.) op een object, waar het manipuleren van gegevens in verband met dat object als volgt:

    Box myBox;           
    
    myBox.getVolume();  

    (uit: http://www.tutorialspoint.com/cplusplus/cpp_class_member_functions.htm)
    beide manieren zijn legaal.

    Ik ben geen expert, maar ik denk dat, als je er slechts één klasse definitie in één bestand, dan maakt het niet echt uit.

    maar als je zoiets als innerlijke klasse, of heb je meerdere class-definitie, de tweede zou moeilijk worden om te lezen en te onderhouden.

    • Can u brengt de relevante inhoud van die koppeling in de hoofdtekst van uw post, en dus toekomstbestendig tegen dode links? Bedankt
  6. 2

    De eerste moet in de header-bestand (waar de verklaring van de klasse zich bevindt). De tweede kan overal, de kop-of, meestal, een bronbestand. In de praktijk je kunt kleine functies in de klasse-declaratie (die verklaart ze impliciet inline, maar het is de compiler die uiteindelijk beslist of ze worden ingevoegd of niet). Echter, de meeste functies hebben een verklaring in de kop-en de uitvoering in een cpp-bestand, zoals in het tweede voorbeeld. En nee, ik zie geen reden waarom dit zou minder leesbaar. En niet te vergeten je eigenlijk zou kunnen splitsen de uitvoering van een type in verschillende cpp-bestanden.

  7. 1

    Een functie die is gedefinieerd in een klasse is standaard behandeld als een in line functie.
    Een eenvoudige reden waarom u zou moeten definiëren van uw functie buiten:

    Een constructor van de klasse controles voor virtuele functies en initialiseert een virtuele aanwijzer te gebruiken om te verwijzen naar de juiste VTABLE of de bij de virtuele methode tabel, roept de base class constructor, en initialiseert variabelen van de huidige klasse, dus het maakt eigenlijk wat te werken.

    De inline-functies worden gebruikt wanneer de functies zijn niet zo ingewikkeld en vermijdt de overhead van de functie-aanroep. (De overhead is voorzien van een tak springen en op het hardware niveau.)
    En zoals hierboven beschreven, de constructor is niet zo eenvoudig om te worden beschouwd als een in line.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *