हेडर में

हेडर के बारे में

C++ में घोषणाओं को अक्सर परिभाषाओं से अलग रखा जाता है। घोषणाएँ तथाकथित हेडर फाइलों में रखी जाती हैं, और उनसे जुड़े कार्यान्वयन सोर्स फाइलों में रहते हैं। आप हेडर फाइलों को एक API की तरह सोच सकते हैं। हेडर फाइल आपको बताती है कि कोडबेस में क्या मौजूद है, बिना यह बताए कि वह कैसे काम करता है।

हेडर और सोर्स

हेडर फाइलों का सबसे आम फाइल एक्सटेंशन .h है। कुछ प्रोजेक्ट .hpp इस्तेमाल करते हैं, और कुछ एक्सटेंशन बिल्कुल छोड़ देते हैं।

परिभाषाएँ एक अलग .cpp फाइल में रहती हैं। इन हिस्सों को फिर से जोड़ने के लिए सोर्स फाइल की शुरुआत उससे जुड़ी हेडर फाइल को शामिल करने से होती है।

मान लीजिए आप "quick_math" नाम की एक लाइब्रेरी लिखना चाहते हैं, जो "super_root" नाम का एक फंक्शन देती है जिसे आप बार-बार इस्तेमाल करना चाहते हैं। तब ये फाइलें कुछ इस तरह दिखेंगी:

// A file named quick_math.h
#pragma once

namespace quick_math {

double super_root(double x, int n);

}

// A file named quick_math.cpp
#include <cmath>

#include "quick_math.h"

double quick_math::super_root(double x, int n) {
    while (n) {
        x = std::sqrt(x), --n;
    }
    return x;
}

अगर कोई हेडर सिर्फ कार्यान्वयन के लिए ज़रूरी है, तो उसकी #include लाइन सिर्फ सोर्स फाइल में ही लिखनी होती है। हेडर में शामिल हर चीज़ .cpp फाइल में भी उपलब्ध रहती है, जैसे नीचे के उदाहरण में string लाइब्रेरी। ध्यान दें: हेडर फाइल में घोषणा के बाद ; लगाना ज़रूरी है, लेकिन सोर्स फाइल में परिभाषा के बाद नहीं।

क्लास और हेडर

क्लास बहुत जटिल हो सकती हैं, और हेडर तथा सोर्स के बँटवारे से उनका रिश्ता उलझा हुआ लग सकता है। एक तरीका यह हो सकता है कि कार्यान्वयन की सारी बारीकियाँ सोर्स फाइल में रखी जाएँ और सारी घोषणाएँ तथा मेंबर वेरिएबल हेडर में:

// A file named robot_flower.h
#if !defined(ROBOT_FLOWER_H)
#define ROBOT_FLOWER_H

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0);
    void give_water();
    std::string get_name();
    int get_size();
    void start_next_day();
};
}  // namespace robots
#endif

// A file named robot_flower.cpp
#include "robot_flower.h"

robots::Flower::Flower(std::string name, int size) {
    this->name = "Robotica " + name;
    this->size = size;
}

void robots::Flower::start_next_day() {
    if (!needs_water) ++size;
    needs_water = true;
}

std::string robots::Flower::get_name() { return name; }

int robots::Flower::get_size() { return size; }

जब हेडर का इस्तेमाल API के अवलोकन की तरह किया जाता है, तो डिफॉल्ट वैल्यू जैसी जानकारी लोग वहीं ढूँढते हैं। इसलिए कंस्ट्रक्टर के size पैरामीटर की डिफॉल्ट वैल्यू कार्यान्वयन में नहीं, हेडर में संभाली जाती है। सोर्स फाइल में परिभाषाओं के आगे नेमस्पेस robots और क्लास टाइप Flower लगाया जाता है।

एक और तरीका हेडर-ओनली लाइब्रेरी है, जिसमें .cpp फाइल बिल्कुल नहीं होती:

// A file named robot_flower.h
#pragma once

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0) {
        this->name = "Robotica " + name;
        this->size = size;
    }
    void give_water() { needs_water = false; }
    std::string get_name() { return name; }
    int get_size() { return size; }
    void start_next_day() {
        if (!needs_water) ++size;
        needs_water = true;
    }
};
}  // namespace robots

प्रोजेक्ट इन तरीकों का मेल भी इस्तेमाल कर सकते हैं, और हर उपयोग के लिए कौन-सा तरीका सबसे अच्छा बैठता है, इस पर बहुत बहस होती है।

इन्क्लूड गार्ड

आपने ऊपर वाले उदाहरण हेडर फाइल में #pragma once लाइन शायद देखी होगी। इसे इन्क्लूड गार्ड कहते हैं, और यह पक्का करता है कि कंपाइलेशन के दौरान फाइल की सामग्री सिर्फ एक बार शामिल हो, जिससे एरर न हों। इन्क्लूड गार्ड का एक और, ज़्यादा जटिल रूप भी है, जो #ifndef से शुरू होता है और #endif पर खत्म होता है। इसका ब्यौरा नीचे दिया गया है।

int myFunction(int n) {
    if (n < 10) {
        return n;
    } else {
        return myOtherFunction(n / 10);
    }
}

int myOtherFunction(int m) { return myFunction(m / 2); }

int myFunction(int n);       // Forward declaration of myFunction
int myOtherFunction(int m);  // Forward declaration of myOtherFunction

// Definition of myFunction
int myFunction(int n) {
    if (n < 0) {
        return 0;
    } else {
        return myOtherFunction(n - 2);
    }
}

// Definition of myOtherFunction
int myOtherFunction(int m) { return myFunction(m / 2); }

#ifndef MY_HEADER_FILE_H /* any name uniquely mapped to file name */
#define MY_HEADER_FILE_H

// file content

#endif