कोड स्टाइल गाइड

HIDL कोड शैली एंड्रॉइड फ्रेमवर्क में C++ कोड से मिलती जुलती है, जिसमें 4-स्पेस इंडेंट और मिश्रित-केस फ़ाइल नाम हैं। पैकेज घोषणाएँ, आयात और डॉकस्ट्रिंग्स थोड़े से संशोधनों के साथ जावा के समान हैं।

IFoo.hal और types.hal के लिए निम्नलिखित उदाहरण HIDL कोड शैलियों को दर्शाते हैं और प्रत्येक शैली पर विवरण के लिए त्वरित लिंक प्रदान करते हैं ( IFooClientCallback.hal , IBar.hal , और IBaz.hal छोड़े गए हैं)।

hardware/interfaces/foo/1.0/IFoo.hal
/*
 * (License Notice)
 */

package android.hardware.foo@1.0;

import android.hardware.bar@1.0::IBar;

import IBaz;
import IFooClientCallback;

/**
 * IFoo is an interface that…
 */
interface IFoo {

    /**
     * This is a multiline docstring.
     *
     * @return result 0 if successful, nonzero otherwise.
     */
     foo() generates (FooStatus result);

    /**
     * Restart controller by power cycle.
     *
     * @param bar callback interface that…
     * @return result 0 if successful, nonzero otherwise.
     */
    powerCycle(IBar bar) generates (FooStatus result);

    /** Single line docstring. */
    baz();


    /**
     * The bar function.
     *
     * @param clientCallback callback after function is called
     * @param baz related baz object
     * @param data input data blob
     */
    bar(IFooClientCallback clientCallback,
        IBaz baz,
        FooData data);

};
hardware/interfaces/foo/1.0/types.hal
/*
 * (License Notice)
 */

package android.hardware.foo@1.0;

/** Replied status. */
enum Status : int32_t {
    OK,
    /* invalid arguments */
    ERR_ARG,
    /* note, no transport related errors */
    ERR_UNKNOWN = -1,
};

struct ArgData {
    int32_t[20]  someArray;
    vec<uint8_t> data;
};

नामकरण की परंपरा

फ़ंक्शन नाम, वेरिएबल नाम और फ़ाइल नाम वर्णनात्मक होने चाहिए; अति-संक्षिप्तीकरण से बचें. परिवर्णी शब्दों को शब्दों के रूप में मानें (उदाहरण के लिए, INFC के बजाय INfc उपयोग करें)।

निर्देशिका संरचना और फ़ाइल नामकरण

निर्देशिका संरचना इस प्रकार दिखनी चाहिए:

  • ROOT-DIRECTORY
    • MODULE
      • SUBMODULE (वैकल्पिक, एक से अधिक स्तर हो सकता है)
        • VERSION
          • Android.mk
          • I INTERFACE_1 .hal
          • I INTERFACE_2 .hal
          • I INTERFACE_N .hal
          • types.hal (वैकल्पिक)

कहाँ:

  • ROOT-DIRECTORY है:
    • कोर एचआईडीएल पैकेज के लिए hardware/interfaces
    • vendor/ VENDOR /interfaces , जहां VENDOR एक SoC विक्रेता या OEM/ODM को संदर्भित करता है।
  • MODULE एक लोअरकेस शब्द होना चाहिए जो सबसिस्टम का वर्णन करता है (उदाहरण के लिए nfc )। यदि एक से अधिक शब्दों की आवश्यकता है, तो नेस्टेड SUBMODULE उपयोग करें। नेस्टिंग के एक से अधिक स्तर हो सकते हैं।
  • VERSION बिल्कुल वैसा ही संस्करण (मेजर.माइनर) होना चाहिए जैसा कि Versions में वर्णित है।
  • I INTERFACE_X इंटरफ़ेस नाम में वर्णित अनुसार UpperCamelCase / PascalCase (जैसे INfc ) के साथ इंटरफ़ेस नाम होना चाहिए।

उदाहरण:

  • hardware/interfaces
    • nfc
      • 1.0
        • Android.mk
        • INfc.hal
        • INfcClientCallback.hal
        • types.hal

नोट: सभी फ़ाइलों में गैर-निष्पादन योग्य अनुमतियाँ (Git में) होनी चाहिए।

पैकेज के नाम

पैकेज नामों को निम्नलिखित पूर्ण-योग्य नाम (FQN) प्रारूप ( PACKAGE-NAME के रूप में संदर्भित) का उपयोग करना चाहिए:

PACKAGE.MODULE[.SUBMODULE[.SUBMODULE[…]]]@VERSION

कहाँ:

  • PACKAGE वह पैकेज है जो ROOT-DIRECTORY को मैप करता है। विशेष रूप से, PACKAGE है:
    • कोर HIDL पैकेज के लिए android.hardware ( hardware/interfaces पर मैपिंग)।
    • vendor. VENDOR .hardware विक्रेता पैकेज के लिए vendor. VENDOR .hardware , जहां VENDOR एक SoC विक्रेता या OEM/ODM को संदर्भित करता है ( vendor/ VENDOR /interfaces के लिए मैपिंग)।
  • MODULE [. SUBMODULE [. SUBMODULE […]]]@ VERSION निर्देशिका संरचना में वर्णित संरचना में बिल्कुल वही फ़ोल्डर नाम हैं।
  • पैकेज के नाम छोटे अक्षरों में होने चाहिए. यदि वे एक शब्द से अधिक लंबे हैं, तो शब्दों को या तो सबमॉड्यूल के रूप में उपयोग किया जाना चाहिए या snake_case में लिखा जाना चाहिए।
  • किसी भी स्थान की अनुमति नहीं है.

FQN का उपयोग हमेशा पैकेज घोषणाओं में किया जाता है।

संस्करणों

संस्करणों में निम्नलिखित प्रारूप होना चाहिए:

MAJOR.MINOR

MAJOR और MINOR दोनों संस्करण एक पूर्णांक होने चाहिए। HIDL सिमेंटिक वर्जनिंग नियमों का उपयोग करता है।

आयात

किसी आयात में निम्नलिखित तीन प्रारूपों में से एक होता है:

  • संपूर्ण-पैकेज आयात: import PACKAGE-NAME ;
  • आंशिक आयात: import PACKAGE-NAME :: UDT ; (या, यदि आयातित प्रकार एक ही पैकेज में है, import UDT ;
  • प्रकार-केवल आयात: import PACKAGE-NAME ::types;

PACKAGE-NAME पैकेज नामों के प्रारूप का अनुसरण करता है। वर्तमान पैकेज का types.hal (यदि यह मौजूद है) स्वचालित रूप से आयात किया जाता है (इसे स्पष्ट रूप से आयात न करें)।

पूर्णतः योग्य नाम (FQNs)

उपयोगकर्ता-परिभाषित प्रकार के आयात के लिए पूर्णतः योग्य नामों का उपयोग केवल तभी करें जब आवश्यक हो। यदि आयात प्रकार एक ही पैकेज में है तो PACKAGE-NAME हटा दें। FQN में रिक्त स्थान नहीं होना चाहिए. पूर्णतः योग्य नाम का उदाहरण:

android.hardware.nfc@1.0::INfcClientCallback

android.hardware.nfc@1.0 के अंतर्गत एक अन्य फ़ाइल में, उपरोक्त इंटरफ़ेस को INfcClientCallback के रूप में देखें। अन्यथा, केवल पूर्णतः योग्य नाम का ही उपयोग करें.

आयातों को समूहीकृत करना और क्रमबद्ध करना

पैकेज घोषणा के बाद (आयात से पहले) एक खाली लाइन का उपयोग करें। प्रत्येक आयात को एक ही पंक्ति पर कब्जा करना चाहिए और इंडेंट नहीं किया जाना चाहिए। निम्नलिखित क्रम में समूह आयात करें:

  1. अन्य android.hardware पैकेज (पूरी तरह से योग्य नामों का उपयोग करें)।
  2. अन्य vendor. VENDOR पैकेज (पूरी तरह से योग्य नामों का उपयोग करें)।
    • प्रत्येक विक्रेता का एक समूह होना चाहिए.
    • विक्रेताओं को वर्णानुक्रम में ऑर्डर करें।
  3. एक ही पैकेज में अन्य इंटरफेस से आयात (सरल नामों का उपयोग करें)।

समूहों के बीच एक खाली रेखा का प्रयोग करें. प्रत्येक समूह के अंदर, आयातों को वर्णानुक्रम में क्रमबद्ध करें। उदाहरण:

import android.hardware.nfc@1.0::INfc;
import android.hardware.nfc@1.0::INfcClientCallback;

/* Importing the whole module. */
import vendor.barvendor.bar@3.1;

import vendor.foovendor.foo@2.2::IFooBar;
import vendor.foovendor.foo@2.2::IFooFoo;

import IBar;
import IFoo;

इंटरफ़ेस नाम

इंटरफ़ेस नाम I से शुरू होने चाहिए, उसके बाद UpperCamelCase / PascalCase नाम होना चाहिए। IFoo नाम वाला एक इंटरफ़ेस IFoo.hal फ़ाइल में परिभाषित किया जाना चाहिए। इस फ़ाइल में केवल IFoo इंटरफ़ेस की परिभाषाएँ हो सकती हैं (इंटरफ़ेस I NAME I NAME .hal में होना चाहिए)।

कार्य

फ़ंक्शन नामों, तर्कों और रिटर्न वेरिएबल नामों के लिए, lowerCamelCase उपयोग करें। उदाहरण:

open(INfcClientCallback clientCallback) generates (int32_t retVal);
oneway pingAlive(IFooCallback cb);

संरचना/संघ क्षेत्र के नाम

स्ट्रक्चर/यूनियन फ़ील्ड नामों के लिए, lowerCamelCase का उपयोग करें। उदाहरण:

struct FooReply {
    vec<uint8_t> replyData;
}

नाम टाइप करें

टाइप नाम स्ट्रक्चर/यूनियन परिभाषाओं, एनम प्रकार परिभाषाओं और typedef एस को संदर्भित करते हैं। इन नामों के लिए, UpperCamelCase / PascalCase का उपयोग करें। उदाहरण:

enum NfcStatus : int32_t {
    /*...*/
};
struct NfcData {
    /*...*/
};

एनम मान

Enum मान UPPER_CASE_WITH_UNDERSCORES होना चाहिए। एनम मानों को फ़ंक्शन तर्कों के रूप में पास करते समय और उन्हें फ़ंक्शन रिटर्न के रूप में लौटाते समय, वास्तविक एनम प्रकार का उपयोग करें (अंतर्निहित पूर्णांक प्रकार का नहीं)। उदाहरण:

enum NfcStatus : int32_t {
    HAL_NFC_STATUS_OK               = 0,
    HAL_NFC_STATUS_FAILED           = 1,
    HAL_NFC_STATUS_ERR_TRANSPORT    = 2,
    HAL_NFC_STATUS_ERR_CMD_TIMEOUT  = 3,
    HAL_NFC_STATUS_REFUSED          = 4
};

नोट: एनम प्रकार का अंतर्निहित प्रकार कोलन के बाद स्पष्ट रूप से घोषित किया जाता है। चूंकि यह कंपाइलर पर निर्भर नहीं है, इसलिए वास्तविक एनम प्रकार का उपयोग करना अधिक स्पष्ट है।

एनम मानों के लिए पूरी तरह से योग्य नामों के लिए, एनम प्रकार के नाम और एनम मान नाम के बीच एक कोलन का उपयोग किया जाता है:

PACKAGE-NAME::UDT[.UDT[.UDT[…]]:ENUM_VALUE_NAME

पूर्णतः योग्य नाम के अंदर रिक्त स्थान नहीं होना चाहिए। आवश्यक होने पर ही पूर्णतः योग्य नाम का उपयोग करें और अनावश्यक भागों को हटा दें। उदाहरण:

android.hardware.foo@1.0::IFoo.IFooInternal.FooEnum:ENUM_OK

टिप्पणियाँ

एक पंक्ति की टिप्पणी के लिए, // , /* */ , और /** */ ठीक हैं।

// This is a single line comment
/* This is also single line comment */
/** This is documentation comment */
  • टिप्पणियों के लिए /* */ प्रयोग करें। जबकि HIDL टिप्पणियों के लिए // का समर्थन करता है, उन्हें हतोत्साहित किया जाता है क्योंकि वे जेनरेट किए गए आउटपुट में दिखाई नहीं देते हैं।
  • जेनरेट किए गए दस्तावेज़ के लिए /** */ का उपयोग करें। इन्हें केवल प्रकार, विधि, फ़ील्ड और एनम मान घोषणाओं पर लागू किया जा सकता है। उदाहरण:
    /** Replied status */
    enum TeleportStatus {
        /** Object entirely teleported. */
        OK              = 0,
        /** Methods return this if teleportation is not completed. */
        ERROR_TELEPORT  = 1,
        /**
         * Teleportation could not be completed due to an object
         * obstructing the path.
         */
        ERROR_OBJECT    = 2,
        ...
    }
    
  • एक अलग पंक्ति में /** के साथ बहु-पंक्ति टिप्पणियाँ प्रारंभ करें। प्रत्येक पंक्ति के आरंभ में * प्रयोग करें। तारांकन को संरेखित करते हुए एक अलग लाइन पर */ के साथ टिप्पणी समाप्त करें। उदाहरण:
    /**
     * My multi-line
     * comment
     */
    
  • लाइसेंसिंग नोटिस और चेंजलॉग को /* (एक एकल तारांकन) के साथ एक नई लाइन शुरू करनी चाहिए, प्रत्येक पंक्ति की शुरुआत में * उपयोग करें, और अंतिम पंक्ति पर */ अपने आप रखें (तारांकन संरेखित होना चाहिए)। उदाहरण:
    /*
     * Copyright (C) 2017 The Android Open Source Project
     * ...
     */
    
    /*
     * Changelog:
     * ...
     */
    

टिप्पणियाँ फ़ाइल करें

प्रत्येक फ़ाइल को उचित लाइसेंसिंग नोटिस के साथ प्रारंभ करें। कोर एचएएल के लिए, यह development/docs/copyright-templates/c.txt में AOSP Apache लाइसेंस होना चाहिए। वर्ष को अद्यतन करना और ऊपर बताए अनुसार /* */ शैली बहु-पंक्ति टिप्पणियों का उपयोग करना याद रखें।

आप वैकल्पिक रूप से लाइसेंस नोटिस के बाद एक खाली लाइन लगा सकते हैं, जिसके बाद चेंजलॉग/वर्जनिंग जानकारी दी जा सकती है। जैसा कि ऊपर बताया गया है, /* */ स्टाइल मल्टी-लाइन टिप्पणियों का उपयोग करें, चेंजलॉग के बाद खाली लाइन रखें, फिर पैकेज घोषणा का पालन करें।

TODO टिप्पणियाँ

TODO में सभी बड़े अक्षरों में स्ट्रिंग TODO और उसके बाद एक कोलन शामिल होना चाहिए। उदाहरण:

// TODO: remove this code before foo is checked in.

TODO टिप्पणियों की अनुमति केवल विकास के दौरान ही दी जाती है; वे प्रकाशित इंटरफ़ेस में मौजूद नहीं होने चाहिए.

इंटरफ़ेस/फ़ंक्शन टिप्पणियाँ (डॉकस्ट्रिंग्स)

मल्टी-लाइन और सिंगल लाइन डॉकस्ट्रिंग्स के लिए /** */ का उपयोग करें। डॉकस्ट्रिंग्स के लिए // उपयोग न करें।

इंटरफ़ेस के लिए डॉकस्ट्रिंग को इंटरफ़ेस के सामान्य तंत्र, डिज़ाइन तर्क, उद्देश्य आदि का वर्णन करना चाहिए। फ़ंक्शन के लिए डॉकस्ट्रिंग फ़ंक्शन के लिए विशिष्ट होना चाहिए (पैकेज-स्तरीय दस्तावेज़ पैकेज निर्देशिका में README फ़ाइल में जाता है)।

/**
 * IFooController is the controller for foos.
 */
interface IFooController {
    /**
     * Opens the controller.
     *
     * @return status HAL_FOO_OK if successful.
     */
    open() generates (FooStatus status);

    /** Close the controller. */
    close();
};

आपको प्रत्येक पैरामीटर/रिटर्न मान के लिए @param s और @return s जोड़ना होगा:

  • प्रत्येक पैरामीटर के लिए @param जोड़ा जाना चाहिए। इसके बाद पैरामीटर का नाम और फिर डॉकस्ट्रिंग आना चाहिए।
  • प्रत्येक रिटर्न मान के लिए @return जोड़ा जाना चाहिए। इसके बाद रिटर्न वैल्यू का नाम और फिर डॉकस्ट्रिंग आना चाहिए।

उदाहरण:

/**
 * Explain what foo does.
 *
 * @param arg1 explain what arg1 is
 * @param arg2 explain what arg2 is
 * @return ret1 explain what ret1 is
 * @return ret2 explain what ret2 is
 */
foo(T arg1, T arg2) generates (S ret1, S ret2);

का प्रारूपण

सामान्य स्वरूपण नियमों में शामिल हैं:

  • दिशा और रेखा । पाठ की प्रत्येक पंक्ति अधिकतम 100 कॉलम लंबी होनी चाहिए।
  • रिक्त स्थान । लाइनों पर कोई अनुगामी रिक्त स्थान नहीं; खाली पंक्तियों में रिक्त स्थान नहीं होना चाहिए।
  • रिक्त स्थान बनाम टैब । केवल रिक्त स्थान का उपयोग करें.
  • इंडेंट आकार . ब्लॉक के लिए 4 स्थान और लाइन रैप के लिए 8 स्थान का उपयोग करें
  • ब्रेसिंग . एनोटेशन मानों को छोड़कर, एक खुला ब्रेस पूर्ववर्ती कोड के समान लाइन पर जाता है लेकिन एक क्लोज ब्रेस और निम्नलिखित अर्धविराम पूरी लाइन पर कब्जा कर लेता है। उदाहरण:
    interface INfc {
        close();
    };
    

पैकेज घोषणा

लाइसेंस नोटिस के बाद पैकेज घोषणा फ़ाइल के शीर्ष पर होनी चाहिए, पूरी लाइन पर होनी चाहिए, और इंडेंटेड नहीं होनी चाहिए। पैकेज निम्नलिखित प्रारूप का उपयोग करके घोषित किए जाते हैं (नाम स्वरूपण के लिए, पैकेज नाम देखें):

package PACKAGE-NAME;

उदाहरण:

package android.hardware.nfc@1.0;

फ़ंक्शन घोषणाएँ

फ़ंक्शन का नाम, पैरामीटर, generates और रिटर्न मान एक ही पंक्ति में होने चाहिए यदि वे फिट हों। उदाहरण:

interface IFoo {
    /** ... */
    easyMethod(int32_t data) generates (int32_t result);
};

यदि वे एक ही पंक्ति में फिट नहीं होते हैं, तो पैरामीटर और रिटर्न मानों को एक ही इंडेंट स्तर पर रखने का प्रयास करें और पाठक को पैरामीटर और रिटर्न मानों को तुरंत देखने में मदद करने के लिए generate अलग करें। उदाहरण:

interface IFoo {
    suchALongMethodThatCannotFitInOneLine(int32_t theFirstVeryLongParameter,
                                          int32_t anotherVeryLongParameter);
    anEvenLongerMethodThatCannotFitInOneLine(int32_t theFirstLongParameter,
                                             int32_t anotherVeryLongParameter)
                                  generates (int32_t theFirstReturnValue,
                                             int32_t anotherReturnValue);
    superSuperSuperSuperSuperSuperSuperLongMethodThatYouWillHateToType(
            int32_t theFirstVeryLongParameter, // 8 spaces
            int32_t anotherVeryLongParameter
        ) generates (
            int32_t theFirstReturnValue,
            int32_t anotherReturnValue
        );
    /* method name is even shorter than 'generates' */
    foobar(AReallyReallyLongType aReallyReallyLongParameter,
           AReallyReallyLongType anotherReallyReallyLongParameter)
        generates (ASuperLongType aSuperLongReturnValue, // 4 spaces
                   ASuperLongType anotherSuperLongReturnValue);
}

अतिरिक्त विवरण:

  • एक खुला कोष्ठक हमेशा फ़ंक्शन नाम के समान पंक्ति पर होता है।
  • फ़ंक्शन नाम और खुले कोष्ठक के बीच कोई स्थान नहीं।
  • कोष्ठक और पैरामीटर के बीच कोई रिक्त स्थान नहीं है , सिवाय इसके कि जब उनके बीच लाइन फ़ीड हो।
  • यदि generates पिछले समापन कोष्ठक के समान पंक्ति पर है, तो पूर्ववर्ती स्थान का उपयोग करें। यदि generates अगले खुले कोष्ठक के समान पंक्ति पर है, तो एक स्थान के साथ अनुसरण करें।
  • सभी पैरामीटर संरेखित करें और मान लौटाएँ (यदि संभव हो)।
  • डिफ़ॉल्ट इंडेंटेशन 4 स्थान है।
  • लपेटे गए पैरामीटर पिछली पंक्ति के पहले पैरामीटर से संरेखित होते हैं, अन्यथा उनके पास 8-स्पेस इंडेंट होता है।

एनोटेशन

एनोटेशन के लिए निम्नलिखित प्रारूप का उपयोग करें:

@annotate(keyword = value, keyword = {value, value, value})

एनोटेशन को वर्णानुक्रम में क्रमबद्ध करें, और समान चिह्नों के आसपास रिक्त स्थान का उपयोग करें। उदाहरण:

@callflow(key = value)
@entry
@exit

सुनिश्चित करें कि एक एनोटेशन पूरी लाइन पर है। उदाहरण:

/* Good */
@entry
@exit

/* Bad */
@entry @exit

यदि एनोटेशन एक ही पंक्ति में फिट नहीं हो सकते हैं, तो 8 रिक्त स्थान के साथ इंडेंट करें। उदाहरण:

@annotate(
        keyword = value,
        keyword = {
                value,
                value
        },
        keyword = value)

यदि संपूर्ण मान सरणी एक ही पंक्ति में फिट नहीं हो सकती है, तो खुले ब्रेसिज़ के बाद लाइन ब्रेक लगाएं { और सरणी के अंदर प्रत्येक अल्पविराम के बाद। अंतिम मान के तुरंत बाद समापन कोष्ठक रखें। यदि केवल एक ही मान हो तो ब्रेसिज़ न लगाएं।

यदि संपूर्ण मान सरणी एक ही पंक्ति में फिट हो सकती है, तो खुले ब्रेसिज़ के बाद और ब्रेसिज़ बंद करने से पहले रिक्त स्थान का उपयोग न करें और प्रत्येक अल्पविराम के बाद एक स्थान का उपयोग करें। उदाहरण:

/* Good */
@callflow(key = {"val", "val"})

/* Bad */
@callflow(key = { "val","val" })

एनोटेशन और फ़ंक्शन घोषणा के बीच खाली पंक्तियाँ नहीं होनी चाहिए। उदाहरण:

/* Good */
@entry
foo();

/* Bad */
@entry

foo();

एनम घोषणाएँ

एनम घोषणाओं के लिए निम्नलिखित नियमों का उपयोग करें:

  • यदि एनम घोषणाएं किसी अन्य पैकेज के साथ साझा की जाती हैं, तो घोषणाओं को इंटरफ़ेस के अंदर एम्बेड करने के बजाय types.hal में रखें।
  • बृहदान्त्र से पहले और बाद में एक स्थान का उपयोग करें, और खुले ब्रेस से पहले अंतर्निहित प्रकार के बाद एक स्थान का उपयोग करें।
  • अंतिम एनम मान में अतिरिक्त अल्पविराम हो भी सकता है और नहीं भी।

संरचनात्मक घोषणाएँ

संरचना घोषणाओं के लिए निम्नलिखित नियमों का उपयोग करें:

  • यदि संरचना घोषणाएं किसी अन्य पैकेज के साथ साझा की जाती हैं, तो घोषणाओं को इंटरफ़ेस के अंदर एम्बेड करने के बजाय types.hal में रखें।
  • खुले ब्रेस से पहले संरचना प्रकार के नाम के बाद एक स्थान का उपयोग करें।
  • फ़ील्ड नाम संरेखित करें (वैकल्पिक)। उदाहरण:
    struct MyStruct {
        vec<uint8_t>   data;
        int32_t        someInt;
    }
    

घोषणाएँ व्यवस्थित करें

निम्नलिखित के बीच रिक्त स्थान न रखें:

  • तत्व प्रकार और खुला वर्गाकार ब्रैकेट।
  • वर्गाकार ब्रैकेट और सरणी आकार खोलें।
  • सरणी का आकार और वर्गाकार ब्रैकेट बंद करें.
  • यदि एक से अधिक आयाम मौजूद हैं, तो वर्गाकार ब्रैकेट और अगला खुला वर्गाकार ब्रैकेट बंद करें।

उदाहरण:

/* Good */
int32_t[5] array;

/* Good */
int32_t[5][6] multiDimArray;

/* Bad */
int32_t [ 5 ] [ 6 ] array;

वैक्टर

निम्नलिखित के बीच रिक्त स्थान न रखें:

  • vec और खुला कोण ब्रैकेट।
  • ओपन एंगल ब्रैकेट और तत्व प्रकार ( अपवाद: तत्व प्रकार भी एक vec है )।
  • तत्व प्रकार और बंद कोण ब्रैकेट ( अपवाद: तत्व प्रकार भी एक vec है)

उदाहरण:

/* Good */
vec<int32_t> array;

/* Good */
vec<vec<int32_t>> array;

/* Good */
vec< vec<int32_t> > array;

/* Bad */
vec < int32_t > array;

/* Bad */
vec < vec < int32_t > > array;