Bazel ट्यूटोरियल: C++ प्रोजेक्ट बनाएं

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है किसी समस्या की शिकायत करें सोर्स देखें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

परिचय

क्या Babel के लिए नए हैं? आप सही जगह पर हैं. Family Link की मदद से, बेज़ल को इस्तेमाल करने का आसान तरीका बताया गया है. इस ट्यूटोरियल में मुख्य शब्दों के बारे में बताया गया है का इस्तेमाल बेज़ल के हिसाब से किया गया है. साथ ही, ये आपको Basel की बुनियादी बातें भी बताए गए हैं वर्कफ़्लो. इसमें आपको अपनी ज़रूरत के लिए तीन टूल मिलेंगे. इसके बाद, आपको तीन चरण पूरे करने होंगे बढ़ती जटिलता के प्रोजेक्ट हैं और जानें कि वे कैसे और क्यों ज़्यादा जटिल होते हैं.

हालांकि Basel एक बिल्ड सिस्टम है, जो कई भाषाओं में वीडियो बनाने की सुविधा देता है. इस ट्यूटोरियल में C++ प्रोजेक्ट का इस्तेमाल उदाहरण के तौर पर किया गया है. के सामान्य दिशा-निर्देश और फ़्लो उपलब्ध कराता है, जो ज़्यादातर भाषाओं पर लागू होते हैं.

पूरा होने का अनुमानित समय: 30 मिनट.

ज़रूरी शर्तें

अगर आपने अभी तक Basel का ऐप्लिकेशन इंस्टॉल नहीं किया है, तो उसे इंस्टॉल करके इसकी शुरुआत करें पहले से मौजूद है. यह ट्यूटोरियल सोर्स कंट्रोल के लिए Git का इस्तेमाल करता है, इसलिए सबसे अच्छे नतीजे मिलते हैं Git इंस्टॉल करें करते हैं.

इसके बाद, नीचे दिए गए निर्देशों का पालन करें:

git clone https://github.com/bazelbuild/examples

इस ट्यूटोरियल के लिए सैंपल प्रोजेक्ट, examples/cpp-tutorial डायरेक्ट्री में है.

इसकी स्ट्रक्चर्ड जानकारी नीचे देखें:

examples
└── cpp-tutorial
    ├──stage1
    │  ├── main
    │  │   ├── BUILD
    │  │   └── hello-world.cc
    │  └── WORKSPACE
    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE
    └──stage3
       ├── main
       │   ├── BUILD
       │   ├── hello-world.cc
       │   ├── hello-greet.cc
       │   └── hello-greet.h
       ├── lib
       │   ├── BUILD
       │   ├── hello-time.cc
       │   └── hello-time.h
       └── WORKSPACE

फ़ाइलों के तीन सेट हैं. हर सेट, इस ट्यूटोरियल में एक चरण को दिखाता है. पहले चरण में, आपको किसी एक पैकेज में मौजूद कोई टारगेट बनाना होगा. दूसरे चरण में, आपको एक ही पैकेज से बाइनरी और लाइब्रेरी, दोनों बनाने में मदद मिलती है. तय सीमा में तीसरा और आखिरी चरण है, तो आपको कई पैकेज वाला एक प्रोजेक्ट बनाना होगा और उसे कई लक्ष्यों के साथ बनाएं.

सारांश: परिचय

Basel (और Git) को इंस्टॉल करके और इस ट्यूटोरियल के लिए रिपॉज़िटरी की क्लोनिंग करके, आप बेज़ल के साथ आपके पहले बिल्ड की बुनियाद रखी है. अगले आइटम पर जाएं सेक्शन में, कुछ शर्तें तय करें और अपना फ़ाइल फ़ोल्डर सेट अप करें.

शुरू करना

फ़ाइल फ़ोल्डर सेट अप करना

प्रोजेक्ट बनाने से पहले, आपको उसका फ़ाइल फ़ोल्डर सेट अप करना होगा. फ़ाइल फ़ोल्डर है एक डायरेक्ट्री, जिसमें आपके प्रोजेक्ट की सोर्स फ़ाइलें और Basel के बिल्ड आउटपुट मौजूद होते हैं. यह इसमें ये अहम फ़ाइलें भी शामिल होती हैं:

  • WORKSPACE file , जो डायरेक्ट्री और उसके कॉन्टेंट की पहचान बेज़ल वर्कस्पेस के तौर पर करता है और प्रोजेक्ट की डायरेक्ट्री स्ट्रक्चर के मूल में मौजूद होती है.
  • एक या एक से ज़्यादा BUILD files , जो बेज़ल को प्रोजेक्ट के अलग-अलग हिस्सों को बनाने का तरीका बताती हैं. ऐप्लिकेशन फ़ाइल फ़ोल्डर में मौजूद डायरेक्ट्री, जिसमें BUILD फ़ाइल है package. (पैकेज के बारे में ज़्यादा जानकारी देखें.)

आने वाले समय में, किसी डायरेक्ट्री को Baze Workspace के तौर पर इस्तेमाल करने के लिए, उस डायरेक्ट्री में WORKSPACE नाम की खाली फ़ाइल है. इस ट्यूटोरियल के लिए, एक WORKSPACE फ़ाइल पहले से ही हर चरण में मौजूद है.

ध्यान दें: Basel का प्रोजेक्ट बनाते समय, सभी इनपुट उसमें होने चाहिए फ़ाइल फ़ोल्डर हो. अलग-अलग फ़ाइल फ़ोल्डर में मौजूद फ़ाइलें, इनसे अलग होती हैं एक-दूसरे का इस्तेमाल करें. वर्कस्पेस के नियमों के बारे में ज़्यादा जानकारी के लिए, ये काम किए जा सकते हैं इस गाइड में दी गई जानकारी देखें.

BUILD फ़ाइल को समझें

BUILD फ़ाइल में Basel के लिए कई अलग-अलग तरह के निर्देश होते हैं. हर BUILD फ़ाइल में कम से कम एक नियम होना ज़रूरी है निर्देशों की मदद से, बज़ल को मनचाहे आउटपुट बनाने का तरीका बताया जाता है. जैसे, एक्ज़ीक्यूटेबल बाइनरी या लाइब्रेरी. बिल्ड नियम की हर इंस्टेंस इसमें BUILD फ़ाइल को टारगेट कहा जाता है और सोर्स फ़ाइलों और डिपेंडेंसी के खास सेट की ओर इशारा करता है. कोई टारगेट, दूसरे टारगेट पर भी ले जा सकता है.

cpp-tutorial/stage1/main डायरेक्ट्री में मौजूद BUILD फ़ाइल पर एक नज़र डालें:

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
)

हमारे उदाहरण में, hello-world टारगेट, Baze के बिल्ट-इन को इंस्टैंशिएट करता है cc_binary rule. यह नियम बेज़ेल को निर्देश देता है कि वह hello-world.cc सोर्स फ़ाइल, किसी पर भी निर्भर नहीं है.

खास जानकारी: शुरू करना

अब आपको कुछ मुख्य शब्दों के बारे में पता है और आपको और आम तौर पर बेज़ल. अगले सेक्शन में, आपको अपने समाचार संगठन के लिए, प्रोजेक्ट का पहला चरण.

पहला चरण: एक ही टारगेट, एक पैकेज

यह प्रोजेक्ट का पहला हिस्सा बनाने का समय है. विज़ुअल रेफ़रंस के लिए, प्रोजेक्ट के पहले चरण के सेक्शन का स्ट्रक्चर यह है:

examples
└── cpp-tutorial
    └──stage1
       ├── main
       │   ├── BUILD
       │   └── hello-world.cc
       └── WORKSPACE

cpp-tutorial/stage1 डायरेक्ट्री पर ले जाने के लिए, नीचे दिया गया तरीका अपनाएं:

cd cpp-tutorial/stage1

इसके बाद, चलाएं:

bazel build //main:hello-world

टारगेट लेबल में, //main: वाला हिस्सा, BUILD फ़ाइल की जगह होता है फ़ाइल फ़ोल्डर के रूट के मुताबिक है और hello-world इसमें टारगेट नाम है BUILD फ़ाइल.

बेज़ल कुछ ऐसा बनाते हैं जो कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.267s, Critical Path: 0.25s

आपने अभी-अभी अपना पहला Basel टारगेट बनाया है. Basel के प्रॉडक्ट की वजह से, bazel-bin डायरेक्ट्री इसके रूट में है name@yourcompany.com जैसा कोई प्रोफ़ेशनल ईमेल पता बनाएं. इससे आपका कारोबार ज़्यादा भरोसेमंद बनेगा.

अब अपनी हाल ही में बनाई गई बाइनरी की जांच करें. इससे:

bazel-bin/main/hello-world

इससे, “Hello world” प्रिंट किया हुआ मैसेज दिखेगा.

यहां पहले चरण का डिपेंडेंसी ग्राफ़ दिया गया है:

हैलो-वर्ल्ड के लिए डिपेंडेंसी ग्राफ़, सिंगल सोर्स फ़ाइल के साथ एक टारगेट दिखाता है.

खास जानकारी: पहला चरण

अब आपने अपना पहला बिल्ड पूरा कर लिया है, आपको इसकी बुनियादी जानकारी है कि कैसे एक स्ट्रक्चर है. अगले चरण में, एक अन्य टेंप्लेट जोड़ा जाएगा और टारगेट.

दूसरा चरण: कई बिल्ड टारगेट

छोटे प्रोजेक्ट के लिए एक ही टारगेट काफ़ी होता है. हालांकि, हो सकता है कि एक से ज़्यादा टारगेट और पैकेज में बड़े प्रोजेक्ट शामिल करना चाहिए. इससे यह तेज़ स्पीड से काम करता है इंक्रीमेंटल बिल्ड – इसका मतलब है कि Baze, बदलावों को सिर्फ़ दोबारा बनाता है – और एक ही बार में किसी प्रोजेक्ट के कई हिस्से बनाकर बनाया जाता है. इसका यह चरण ट्यूटोरियल में टारगेट जोड़ा जाता है और अगले चरण में पैकेज जोड़ा जाता है.

यह वह डायरेक्ट्री है जिसके साथ दूसरे चरण के लिए काम किया जा रहा है:

    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE

cpp-tutorial/stage2/main डायरेक्ट्री में मौजूद BUILD फ़ाइल की झलक देखें:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
    ],
)

इस BUILD फ़ाइल के साथ, Basel ने सबसे पहले hello-greet लाइब्रेरी बनाई (Basel के बिल्ट-इन cc_library rule का इस्तेमाल करके), इसके बाद, hello-world बाइनरी. इसमें deps एट्रिब्यूट hello-world का टारगेट बेज़ल को बताता है कि hello-greet hello-world बाइनरी बनाने के लिए लाइब्रेरी ज़रूरी है.

प्रोजेक्ट का नया वर्शन बनाने से पहले, आपको डायरेक्ट्री में, इसे चलाकर cpp-tutorial/stage2 डायरेक्ट्री पर स्विच किया जा सकता है:

cd ../stage2

अब इस जाने-पहचाने निर्देश का इस्तेमाल करके नई बाइनरी बनाई जा सकती है:

bazel build //main:hello-world

एक बार फिर, बेज़ल कुछ इस तरह पेश करते हैं:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.399s, Critical Path: 0.30s

अब आपके पास हाल ही में बनी बाइनरी की जांच करने का विकल्प है. इससे आपको एक और “Hello world” मिलता है:

bazel-bin/main/hello-world

अगर अब hello-greet.cc में बदलाव किया जाता है और प्रोजेक्ट को फिर से बनाया जाता है, तो Baज़र, प्रोजेक्ट को फिर से कंपाइल करता है उस फ़ाइल को कॉपी कर सकते हैं.

डिपेंडेंसी ग्राफ़ में देखें कि hello-world एक अतिरिक्त इनपुट पर निर्भर है hello-greet नाम:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़, फ़ाइल में बदलाव करने के बाद डिपेंडेंसी में होने वाले बदलाव दिखाता है.

खास जानकारी: दूसरा चरण

अब आपने दो टारगेट के साथ प्रोजेक्ट बना लिया है. hello-world टारगेट बनाता है और एक अन्य टारगेट (//main:hello-greet) पर निर्भर है, जो दो अतिरिक्त सोर्स फ़ाइलें बनाता है. अगले सेक्शन में, इसे और बेहतर बनाएं और एक अन्य पैकेज जोड़ें.

तीसरा चरण: एक से ज़्यादा पैकेज

यह अगला चरण, Android स्मार्टवॉच के लिए Android घड़ी के विजेट पर एक और लेयर जोड़ता है. साथ ही, Android TV की मदद से एक प्रोजेक्ट तैयार करता है एक से ज़्यादा पैकेज शामिल हैं. नीचे दिए गए टूल की संरचना और कॉन्टेंट पर एक नज़र डालें cpp-tutorial/stage3 डायरेक्ट्री:

└──stage3
   ├── main
   │   ├── BUILD
   │   ├── hello-world.cc
   │   ├── hello-greet.cc
   │   └── hello-greet.h
   ├── lib
   │   ├── BUILD
   │   ├── hello-time.cc
   │   └── hello-time.h
   └── WORKSPACE

देखा जा सकता है कि अब दो सब-डायरेक्ट्री हैं और हर डायरेक्ट्री में एक BUILD है फ़ाइल से लिए जाते हैं. इसलिए, बैज के लिए, अब फ़ाइल फ़ोल्डर में दो पैकेज शामिल हैं: lib और main.

lib/BUILD फ़ाइल पर एक नज़र डालें:

cc_library(
    name = "hello-time",
    srcs = ["hello-time.cc"],
    hdrs = ["hello-time.h"],
    visibility = ["//main:__pkg__"],
)

और main/BUILD फ़ाइल पर:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
        "//lib:hello-time",
    ],
)

मुख्य पैकेज में hello-world का टारगेट, hello-time के टारगेट पर निर्भर करता है lib पैकेज में (इसलिए लक्ष्य लेबल //lib:hello-time) - Basel को पता है इसे deps एट्रिब्यूट की मदद से इस्तेमाल किया जाता है. इसे डिपेंडेंसी में देखा जा सकता है ग्राफ़:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़ दिखाता है कि मुख्य पैकेज में टारगेट, `lib` पैकेज के टारगेट पर कैसे निर्भर करता है.

कैंपेन को कामयाब बनाने के लिए, lib/BUILD में //lib:hello-time का टारगेट बनाएं यह एट्रिब्यूट, main/BUILD में मौजूद टारगेट को साफ़ तौर पर दिखता है. ऐसा इसलिए है क्योंकि डिफ़ॉल्ट रूप से लक्ष्य केवल उन्हीं अन्य लक्ष्यों को दिखाई देते हैं BUILD फ़ाइल. लाइब्रेरी जैसी समस्याओं से बचने के लिए, Baze टारगेट की गई विज़िबिलिटी का इस्तेमाल करता है इसमें, लागू करने की जानकारी शामिल है जो सार्वजनिक एपीआई में लीक हो रही है.

अब प्रोजेक्ट का यह फ़ाइनल वर्शन बनाएं. cpp-tutorial/stage3 पर स्विच करें निर्देशिका को चलाकर देखें:

cd  ../stage3

एक बार फिर से, नीचे दिया गया निर्देश चलाएं:

bazel build //main:hello-world

बेज़ल कुछ ऐसा बनाते हैं जो कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 0.167s, Critical Path: 0.00s

अब आखिरी Hello world मैसेज के लिए, इस ट्यूटोरियल की आखिरी बाइनरी की जांच करें:

bazel-bin/main/hello-world

खास जानकारी: तीसरा चरण

अब आपने प्रोजेक्ट को तीन लक्ष्यों के साथ दो पैकेज के तौर पर बना लिया है और इन दोनों के बीच एक-दूसरे की निर्भरता होती है. इससे आपको आगे बढ़ने और आने वाले समय में खुद को बेहतर बनाने में मदद मिलती है प्रोजेक्ट पर काम किया. अगले सेक्शन में, जानें कि बेज़ल का सफ़र.

अगले चरण

अब आपने Basel का इस्तेमाल करके, अपना पहला बेसिक बिल्ड पूरा कर लिया है. हालांकि, यह सिर्फ़ शुरू करें. Basel के साथ सीखने के लिए, यहां कुछ और संसाधन दिए गए हैं:

बिल्डिंग बनाने के लिए शुभकामनाएं!