การประกาศฟังก์ชันภายในหรือภายนอกคลาส

ฉันเป็นนักพัฒนา JAVA ที่พยายามเรียนรู้ C ++ แต่ฉันไม่รู้จริงๆว่าแนวทางปฏิบัติที่ดีที่สุดสำหรับการประกาศฟังก์ชันมาตรฐานคืออะไร

ในห้องเรียน:

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

หรือภายนอก:

class Clazz
{
public:
    void Fun1();
}

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

ฉันมีความรู้สึกว่าอันที่สองอ่านได้น้อย ...

C ++ เป็นเชิงวัตถุในแง่ที่สนับสนุนกระบวนทัศน์เชิงวัตถุสำหรับการพัฒนาซอฟต์แวร์

อย่างไรก็ตาม C ++ แตกต่างจาก Java ไม่ได้บังคับให้คุณจัดกลุ่มนิยามฟังก์ชันในคลาส: วิธี C ++ มาตรฐานสำหรับการประกาศฟังก์ชันคือการประกาศฟังก์ชันโดยไม่ต้องมีคลาสใด ๆ

แต่หากคุณมีการพูดคุยเกี่ยวกับวิธีการประกาศ / คำนิยามแล้ววิธีมาตรฐานคือการใส่เพียงการประกาศในแฟ้มรวม (ปกติชื่อ.hหรือ.hpp) และความหมายในแฟ้มการดำเนินงานแยกต่างหาก (ปกติชื่อ.cppหรือ.cxx) ฉันยอมรับว่านี่ค่อนข้างน่ารำคาญและต้องมีการทำซ้ำ แต่มันเป็นวิธีการออกแบบภาษา

สำหรับการทดลองอย่างรวดเร็วและโครงการไฟล์เดียวอะไร ๆ ก็ใช้ได้ ... แต่สำหรับโครงการที่ใหญ่กว่าการแยกนี้เป็นสิ่งที่จำเป็นในทางปฏิบัติ

หมายเหตุ: แม้ว่าคุณจะรู้จัก Java แต่ C ++ ก็เป็นภาษาที่แตกต่างกันโดยสิ้นเชิง ... และเป็นภาษาที่ไม่สามารถเรียนรู้ได้จากการทดลอง เหตุผลก็คือมันเป็นภาษาที่ค่อนข้างซับซ้อนมีตัวเลือกที่ไม่สมมาตรและดูเหมือนจะไร้เหตุผลและที่สำคัญที่สุดคือเมื่อคุณทำผิดพลาดจะไม่มี "runtime error angels" ที่จะช่วยคุณได้เหมือนใน Java ... แต่มีแทน " ภูตพฤติกรรมที่ไม่ได้กำหนด ".

วิธีเดียวที่สมเหตุสมผลในการเรียนรู้ C ++ คือการอ่าน ... ไม่ว่าคุณจะฉลาดแค่ไหนก็ไม่มีทางเดาได้ว่าคณะกรรมการตัดสินใจอะไร (จริงๆแล้วการฉลาดก็อาจเป็นปัญหาได้เพราะคำตอบที่ถูกต้องนั้นไร้เหตุผลและเป็นผลมาจากประวัติศาสตร์ มรดก)

เพียงแค่เลือกหนังสือดีๆสักเล่มหรือสองเล่มแล้วอ่านให้ครอบคลุม

อย่างแรกกำหนดฟังก์ชันสมาชิกของคุณเป็นฟังก์ชันอินไลน์ในขณะที่ฟังก์ชันที่สองไม่ทำ นิยามของฟังก์ชันในกรณีนี้อยู่ในส่วนหัวของตัวเอง

การใช้งานครั้งที่สองจะวางนิยามของฟังก์ชันในไฟล์ cpp

ทั้งสองมีความแตกต่างกันทางความหมายและไม่ใช่แค่เรื่องของรูปแบบเท่านั้น

นิยามฟังก์ชันดีกว่านอกคลาส ด้วยวิธีนี้รหัสของคุณจะปลอดภัยหากจำเป็น ไฟล์ส่วนหัวควรให้การประกาศ

สมมติว่ามีคนต้องการใช้รหัสของคุณคุณสามารถให้ไฟล์. h และไฟล์. obj (ได้มาจากการรวบรวม) ของชั้นเรียนของคุณ เขาไม่ต้องการไฟล์. cpp เพื่อใช้รหัสของคุณ

วิธีนี้จะไม่ปรากฏให้ใครเห็น

เมธอด "ภายในคลาส" (I) ทำเช่นเดียวกับเมธอด "นอกคลาส" (O)

อย่างไรก็ตาม (I) สามารถใช้ได้เมื่อใช้คลาสในไฟล์เดียวเท่านั้น (ภายในไฟล์. cpp) (O) ใช้เมื่ออยู่ในไฟล์ส่วนหัว ไฟล์ cpp จะถูกคอมไพล์เสมอ ไฟล์ส่วนหัวจะถูกคอมไพล์เมื่อคุณใช้ #include "header.h"

หากคุณใช้ (I) ในไฟล์ส่วนหัวฟังก์ชัน (Fun1) จะถูกประกาศทุกครั้งที่คุณใส่ #include "header.h" ซึ่งอาจนำไปสู่การประกาศฟังก์ชันเดียวกันหลายครั้ง คอมไพล์ยากกว่าและอาจทำให้เกิดข้อผิดพลาดได้

ตัวอย่างการใช้งานที่ถูกต้อง:

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. 

ฟังก์ชันสมาชิกสามารถกำหนดได้ภายในนิยามคลาสหรือแยกกันโดยใช้ตัวดำเนินการความละเอียดขอบเขต ::. การกำหนดฟังก์ชันสมาชิกภายในนิยามคลาสจะประกาศฟังก์ชันอินไลน์แม้ว่าคุณจะไม่ได้ใช้ตัวระบุอินไลน์ก็ตาม ดังนั้นคุณสามารถกำหนดฟังก์ชัน Volume () ดังต่อไปนี้:

class Box
{
  public:

     double length;
     double breadth;    
     double height;     

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

หากคุณต้องการคุณสามารถกำหนดฟังก์ชันเดียวกันนอกคลาสโดยใช้ตัวดำเนินการความละเอียดขอบเขต :: ดังนี้

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

ที่นี่ประเด็นสำคัญเพียงอย่างเดียวคือคุณจะต้องใช้ชื่อคลาสก่อน :: operator ฟังก์ชันสมาชิกจะถูกเรียกใช้โดยใช้ตัวดำเนินการจุด (.) บนวัตถุซึ่งจะจัดการกับข้อมูลที่เกี่ยวข้องกับวัตถุนั้นเท่านั้นดังนี้:

Box myBox;           

myBox.getVolume();  

(จาก: http://www.tutorialspoint.com/cplusplus/cpp_class_member_functions.htm ) ทั้งสองวิธีถูกต้องตามกฎหมาย

ฉันไม่ใช่ผู้เชี่ยวชาญ แต่ฉันคิดว่าถ้าคุณใส่นิยามคลาสเดียวในไฟล์เดียวมันก็ไม่สำคัญ

แต่ถ้าคุณใช้บางอย่างเช่นคลาสภายในหรือคุณมีนิยามคลาสหลายคลาสคลาสที่สองจะอ่านและดูแลได้ยาก

รายการแรกจะต้องใส่ไว้ในไฟล์ส่วนหัว (ซึ่งมีการประกาศของคลาสอยู่) อย่างที่สองสามารถอยู่ที่ใดก็ได้ทั้งส่วนหัวหรือโดยปกติจะเป็นไฟล์ต้นฉบับ ในทางปฏิบัติคุณสามารถใส่ฟังก์ชั่นเล็ก ๆ ในการประกาศคลาสได้ (ซึ่งจะประกาศโดยปริยายแบบอินไลน์แม้ว่าจะเป็นคอมไพเลอร์ที่ตัดสินใจในท้ายที่สุดว่าจะอินไลน์หรือไม่ก็ตาม) อย่างไรก็ตามฟังก์ชันส่วนใหญ่มีการประกาศในส่วนหัวและการนำไปใช้ในไฟล์ cpp เช่นในตัวอย่างที่สองของคุณ และไม่ฉันไม่เห็นเหตุผลว่าทำไมสิ่งนี้จึงอ่านได้น้อยลง ไม่ต้องพูดถึงคุณสามารถแยกการใช้งานสำหรับประเภทในไฟล์ cpp ได้หลายไฟล์

ฟังก์ชันที่กำหนดไว้ภายในคลาสจะถือว่าเป็นฟังก์ชันอินไลน์ตามค่าเริ่มต้น เหตุผลง่ายๆที่คุณควรกำหนดฟังก์ชันของคุณภายนอก:

ตัวสร้างของคลาสจะตรวจสอบฟังก์ชันเสมือนและเริ่มต้นตัวชี้เสมือนเพื่อชี้ไปที่ VTABLE ที่เหมาะสมหรือตารางวิธีการเสมือนเรียกตัวสร้างคลาสฐานและเริ่มต้นตัวแปรของคลาสปัจจุบันดังนั้นจึงทำงานได้จริง

ฟังก์ชันอินไลน์จะใช้เมื่อฟังก์ชันไม่ซับซ้อนและหลีกเลี่ยงค่าใช้จ่ายในการเรียกฟังก์ชัน (ค่าใช้จ่ายรวมถึงการกระโดดและการแตกแขนงในระดับฮาร์ดแวร์) และตามที่อธิบายไว้ข้างต้นตัวสร้างไม่ง่ายอย่างที่คิดเหมือนแบบอินไลน์

ฟังก์ชันแบบอินไลน์ (ฟังก์ชันเมื่อคุณประกาศในคลาส) ทุกครั้งเมื่อเรียกใช้ฟังก์ชันเหล่านี้จะถูกวางในรหัสหน่วยความจำหลักของคุณ ในขณะที่คุณประกาศฟังก์ชันนอกคลาสเมื่อคุณเรียกใช้ฟังก์ชันนั้นมาจากหน่วยความจำเดียวกัน นั่นเป็นเหตุผลที่ดีกว่ามาก