Idiomatic way to prevent slicing? The 2019 Stack Overflow Developer Survey Results Are InForce function to be called only with specific typesWhat's the best way to trim std::string?What is object slicing?What's the point of g++ -Wreorder?Easiest way to convert int to string in C++Does the C++ spec allow an instance of a non-virtual class to include memory for a vtable pointer?capture variables inside of subclass?Detecting if a type can be derived from in C++C++ overload function by return typeIs using inline classes inside a function permitted to be used as template types?Short-circuit evaluation and assignment in C++

Realistic Alternatives to Dust: What Else Could Feed a Plankton Bloom?

What does Linus Torvalds mean when he says that Git "never ever" tracks a file?

Why is my p-value correlated to difference between means in two sample tests?

Does duplicating a spell with Wish count as casting that spell?

Monty Hall variation

Falsification in Math vs Science

"To split hairs" vs "To be pedantic"

Unbreakable Formation vs. Cry of the Carnarium

Why do UK politicians seemingly ignore opinion polls on Brexit?

Is it possible for the two major parties in the UK to form a coalition with each other instead of a much smaller party?

What is the best strategy for white in this position?

The difference between dialogue marks

What is a mixture ratio of propellant?

Is this food a bread or a loaf?

What is the steepest angle that a canal can be traversable without locks?

How to deal with fear of taking dependencies

On the insanity of kings as an argument against monarchy

If a poisoned arrow's piercing damage is reduced to 0, do you still get poisoned?

Access elements in std::string where positon of string is greater than its size

Why Did Howard Stark Use All The Vibranium They Had On A Prototype Shield?

What are the motivations for publishing new editions of an existing textbook, beyond new discoveries in a field?

Confusion about non-derivable continuous functions

What do hard-Brexiteers want with respect to the Irish border?

Geography at the pixel level



Idiomatic way to prevent slicing?



The 2019 Stack Overflow Developer Survey Results Are InForce function to be called only with specific typesWhat's the best way to trim std::string?What is object slicing?What's the point of g++ -Wreorder?Easiest way to convert int to string in C++Does the C++ spec allow an instance of a non-virtual class to include memory for a vtable pointer?capture variables inside of subclass?Detecting if a type can be derived from in C++C++ overload function by return typeIs using inline classes inside a function permitted to be used as template types?Short-circuit evaluation and assignment in C++



.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty height:90px;width:728px;box-sizing:border-box;








9















Sometimes it can be an annoyance that c++ defaults to allow slicing. For example



#include <iostream>
struct foo int a; ;
struct bar : foo int b; ;

int main()
bar x1,2;
foo y = x; // <- I dont want this to compile!



This compiles and runs as expected! Though, what if I dont want to enable slicing?



What is the idomatic way to write foo such that one cannot slice instances of any derived class?










share|improve this question






























    9















    Sometimes it can be an annoyance that c++ defaults to allow slicing. For example



    #include <iostream>
    struct foo int a; ;
    struct bar : foo int b; ;

    int main()
    bar x1,2;
    foo y = x; // <- I dont want this to compile!



    This compiles and runs as expected! Though, what if I dont want to enable slicing?



    What is the idomatic way to write foo such that one cannot slice instances of any derived class?










    share|improve this question


























      9












      9








      9


      3






      Sometimes it can be an annoyance that c++ defaults to allow slicing. For example



      #include <iostream>
      struct foo int a; ;
      struct bar : foo int b; ;

      int main()
      bar x1,2;
      foo y = x; // <- I dont want this to compile!



      This compiles and runs as expected! Though, what if I dont want to enable slicing?



      What is the idomatic way to write foo such that one cannot slice instances of any derived class?










      share|improve this question
















      Sometimes it can be an annoyance that c++ defaults to allow slicing. For example



      #include <iostream>
      struct foo int a; ;
      struct bar : foo int b; ;

      int main()
      bar x1,2;
      foo y = x; // <- I dont want this to compile!



      This compiles and runs as expected! Though, what if I dont want to enable slicing?



      What is the idomatic way to write foo such that one cannot slice instances of any derived class?







      c++ inheritance object-slicing






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited 3 hours ago









      rrauenza

      3,55921835




      3,55921835










      asked 7 hours ago









      user463035818user463035818

      18.8k42970




      18.8k42970






















          3 Answers
          3






          active

          oldest

          votes


















          12














          I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to



          struct foo 

          int a;
          foo() = default; // you have to add this because of the template constructor

          template<typename T>
          foo(const T&) = delete; // error trying to copy anything but a foo

          template<typename T>
          foo& operator=(const T&) = delete; // error assigning anything else but a foo
          ;


          then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.






          share|improve this answer

























          • Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

            – eerorika
            6 hours ago











          • if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

            – user463035818
            6 hours ago






          • 1





            @user463035818 Yep. I've been using it since I've asked that Q.

            – NathanOliver
            6 hours ago






          • 3





            I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

            – NathanOliver
            6 hours ago



















          4














          Since 2011, the idiomatic way has been to use auto:



          #include <iostream>
          struct foo int a; ;
          struct bar : foo int b; ;

          int main()
          bar x1,2;
          auto y = x; // <- y is a bar



          If you wish to actively prevent slicing, there are a number of ways:



          Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:



          #include <iostream>

          struct foo int a; ;
          struct bar

          bar(int a, int b)
          : foo_(a)
          , b(b)


          int b;

          int get_a() const return foo_.a;

          private:
          foo foo_;
          ;

          int main()
          bar x1,2;
          // foo y = x; // <- does not compile




          Another more specialised way might be to alter the permissions around copy operators:



          #include <iostream>

          struct foo
          int a;
          protected:
          foo(foo const&) = default;
          foo(foo&&) = default;
          foo& operator=(foo const&) = default;
          foo& operator=(foo&&) = default;

          ;

          struct bar : foo

          bar(int a, int b)
          : fooa, bb


          int b;
          ;

          int main()
          auto x = bar (1,2);
          // foo y = x; // <- does not compile






          share|improve this answer






























            3














            You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:



            struct foo 
            // ...
            protected:
            foo(foo&) = default;
            ;





            share|improve this answer


















            • 4





              but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

              – user463035818
              6 hours ago











            Your Answer






            StackExchange.ifUsing("editor", function ()
            StackExchange.using("externalEditor", function ()
            StackExchange.using("snippets", function ()
            StackExchange.snippets.init();
            );
            );
            , "code-snippets");

            StackExchange.ready(function()
            var channelOptions =
            tags: "".split(" "),
            id: "1"
            ;
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function()
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled)
            StackExchange.using("snippets", function()
            createEditor();
            );

            else
            createEditor();

            );

            function createEditor()
            StackExchange.prepareEditor(
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader:
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            ,
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            );



            );













            draft saved

            draft discarded


















            StackExchange.ready(
            function ()
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55600025%2fidiomatic-way-to-prevent-slicing%23new-answer', 'question_page');

            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            12














            I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to



            struct foo 

            int a;
            foo() = default; // you have to add this because of the template constructor

            template<typename T>
            foo(const T&) = delete; // error trying to copy anything but a foo

            template<typename T>
            foo& operator=(const T&) = delete; // error assigning anything else but a foo
            ;


            then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.






            share|improve this answer

























            • Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

              – eerorika
              6 hours ago











            • if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

              – user463035818
              6 hours ago






            • 1





              @user463035818 Yep. I've been using it since I've asked that Q.

              – NathanOliver
              6 hours ago






            • 3





              I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

              – NathanOliver
              6 hours ago
















            12














            I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to



            struct foo 

            int a;
            foo() = default; // you have to add this because of the template constructor

            template<typename T>
            foo(const T&) = delete; // error trying to copy anything but a foo

            template<typename T>
            foo& operator=(const T&) = delete; // error assigning anything else but a foo
            ;


            then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.






            share|improve this answer

























            • Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

              – eerorika
              6 hours ago











            • if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

              – user463035818
              6 hours ago






            • 1





              @user463035818 Yep. I've been using it since I've asked that Q.

              – NathanOliver
              6 hours ago






            • 3





              I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

              – NathanOliver
              6 hours ago














            12












            12








            12







            I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to



            struct foo 

            int a;
            foo() = default; // you have to add this because of the template constructor

            template<typename T>
            foo(const T&) = delete; // error trying to copy anything but a foo

            template<typename T>
            foo& operator=(const T&) = delete; // error assigning anything else but a foo
            ;


            then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.






            share|improve this answer















            I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to



            struct foo 

            int a;
            foo() = default; // you have to add this because of the template constructor

            template<typename T>
            foo(const T&) = delete; // error trying to copy anything but a foo

            template<typename T>
            foo& operator=(const T&) = delete; // error assigning anything else but a foo
            ;


            then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 6 hours ago

























            answered 6 hours ago









            NathanOliverNathanOliver

            98.5k16138218




            98.5k16138218












            • Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

              – eerorika
              6 hours ago











            • if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

              – user463035818
              6 hours ago






            • 1





              @user463035818 Yep. I've been using it since I've asked that Q.

              – NathanOliver
              6 hours ago






            • 3





              I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

              – NathanOliver
              6 hours ago


















            • Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

              – eerorika
              6 hours ago











            • if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

              – user463035818
              6 hours ago






            • 1





              @user463035818 Yep. I've been using it since I've asked that Q.

              – NathanOliver
              6 hours ago






            • 3





              I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

              – NathanOliver
              6 hours ago

















            Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

            – eerorika
            6 hours ago





            Note that this doesn't prevent explicit slicing like this: foo y = static_cast<foo&>(x);. That said, perhaps it's not a problem to OP.

            – eerorika
            6 hours ago













            if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

            – user463035818
            6 hours ago





            if I understand correctly this is a nice way to prevent implicit conversions for function parameters in general

            – user463035818
            6 hours ago




            1




            1





            @user463035818 Yep. I've been using it since I've asked that Q.

            – NathanOliver
            6 hours ago





            @user463035818 Yep. I've been using it since I've asked that Q.

            – NathanOliver
            6 hours ago




            3




            3





            I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

            – NathanOliver
            6 hours ago






            I look at it as reverse SFINAE. You make the overloads you want to compile, and then add a deleted template stopping everything else.

            – NathanOliver
            6 hours ago














            4














            Since 2011, the idiomatic way has been to use auto:



            #include <iostream>
            struct foo int a; ;
            struct bar : foo int b; ;

            int main()
            bar x1,2;
            auto y = x; // <- y is a bar



            If you wish to actively prevent slicing, there are a number of ways:



            Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:



            #include <iostream>

            struct foo int a; ;
            struct bar

            bar(int a, int b)
            : foo_(a)
            , b(b)


            int b;

            int get_a() const return foo_.a;

            private:
            foo foo_;
            ;

            int main()
            bar x1,2;
            // foo y = x; // <- does not compile




            Another more specialised way might be to alter the permissions around copy operators:



            #include <iostream>

            struct foo
            int a;
            protected:
            foo(foo const&) = default;
            foo(foo&&) = default;
            foo& operator=(foo const&) = default;
            foo& operator=(foo&&) = default;

            ;

            struct bar : foo

            bar(int a, int b)
            : fooa, bb


            int b;
            ;

            int main()
            auto x = bar (1,2);
            // foo y = x; // <- does not compile






            share|improve this answer



























              4














              Since 2011, the idiomatic way has been to use auto:



              #include <iostream>
              struct foo int a; ;
              struct bar : foo int b; ;

              int main()
              bar x1,2;
              auto y = x; // <- y is a bar



              If you wish to actively prevent slicing, there are a number of ways:



              Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:



              #include <iostream>

              struct foo int a; ;
              struct bar

              bar(int a, int b)
              : foo_(a)
              , b(b)


              int b;

              int get_a() const return foo_.a;

              private:
              foo foo_;
              ;

              int main()
              bar x1,2;
              // foo y = x; // <- does not compile




              Another more specialised way might be to alter the permissions around copy operators:



              #include <iostream>

              struct foo
              int a;
              protected:
              foo(foo const&) = default;
              foo(foo&&) = default;
              foo& operator=(foo const&) = default;
              foo& operator=(foo&&) = default;

              ;

              struct bar : foo

              bar(int a, int b)
              : fooa, bb


              int b;
              ;

              int main()
              auto x = bar (1,2);
              // foo y = x; // <- does not compile






              share|improve this answer

























                4












                4








                4







                Since 2011, the idiomatic way has been to use auto:



                #include <iostream>
                struct foo int a; ;
                struct bar : foo int b; ;

                int main()
                bar x1,2;
                auto y = x; // <- y is a bar



                If you wish to actively prevent slicing, there are a number of ways:



                Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:



                #include <iostream>

                struct foo int a; ;
                struct bar

                bar(int a, int b)
                : foo_(a)
                , b(b)


                int b;

                int get_a() const return foo_.a;

                private:
                foo foo_;
                ;

                int main()
                bar x1,2;
                // foo y = x; // <- does not compile




                Another more specialised way might be to alter the permissions around copy operators:



                #include <iostream>

                struct foo
                int a;
                protected:
                foo(foo const&) = default;
                foo(foo&&) = default;
                foo& operator=(foo const&) = default;
                foo& operator=(foo&&) = default;

                ;

                struct bar : foo

                bar(int a, int b)
                : fooa, bb


                int b;
                ;

                int main()
                auto x = bar (1,2);
                // foo y = x; // <- does not compile






                share|improve this answer













                Since 2011, the idiomatic way has been to use auto:



                #include <iostream>
                struct foo int a; ;
                struct bar : foo int b; ;

                int main()
                bar x1,2;
                auto y = x; // <- y is a bar



                If you wish to actively prevent slicing, there are a number of ways:



                Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:



                #include <iostream>

                struct foo int a; ;
                struct bar

                bar(int a, int b)
                : foo_(a)
                , b(b)


                int b;

                int get_a() const return foo_.a;

                private:
                foo foo_;
                ;

                int main()
                bar x1,2;
                // foo y = x; // <- does not compile




                Another more specialised way might be to alter the permissions around copy operators:



                #include <iostream>

                struct foo
                int a;
                protected:
                foo(foo const&) = default;
                foo(foo&&) = default;
                foo& operator=(foo const&) = default;
                foo& operator=(foo&&) = default;

                ;

                struct bar : foo

                bar(int a, int b)
                : fooa, bb


                int b;
                ;

                int main()
                auto x = bar (1,2);
                // foo y = x; // <- does not compile







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 6 hours ago









                Richard HodgesRichard Hodges

                57k658105




                57k658105





















                    3














                    You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:



                    struct foo 
                    // ...
                    protected:
                    foo(foo&) = default;
                    ;





                    share|improve this answer


















                    • 4





                      but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                      – user463035818
                      6 hours ago















                    3














                    You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:



                    struct foo 
                    // ...
                    protected:
                    foo(foo&) = default;
                    ;





                    share|improve this answer


















                    • 4





                      but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                      – user463035818
                      6 hours ago













                    3












                    3








                    3







                    You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:



                    struct foo 
                    // ...
                    protected:
                    foo(foo&) = default;
                    ;





                    share|improve this answer













                    You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:



                    struct foo 
                    // ...
                    protected:
                    foo(foo&) = default;
                    ;






                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered 6 hours ago









                    eerorikaeerorika

                    89.8k664136




                    89.8k664136







                    • 4





                      but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                      – user463035818
                      6 hours ago












                    • 4





                      but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                      – user463035818
                      6 hours ago







                    4




                    4





                    but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                    – user463035818
                    6 hours ago





                    but then I cannot copy foos anymore :( I'd like to prevent only copying a bar to a foo if possible

                    – user463035818
                    6 hours ago

















                    draft saved

                    draft discarded
















































                    Thanks for contributing an answer to Stack Overflow!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid


                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.

                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function ()
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55600025%2fidiomatic-way-to-prevent-slicing%23new-answer', 'question_page');

                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    Popular posts from this blog

                    Can not update quote_id field of “quote_item” table magento 2Magento 2.1 - We can't remove the item. (Shopping Cart doesnt allow us to remove items before becomes empty)Add value for custom quote item attribute using REST apiREST API endpoint v1/carts/cartId/items always returns error messageCorrect way to save entries to databaseHow to remove all associated quote objects of a customer completelyMagento 2 - Save value from custom input field to quote_itemGet quote_item data using quote id and product id filter in Magento 2How to set additional data to quote_item table from controller in Magento 2?What is the purpose of additional_data column in quote_item table in magento2Set Custom Price to Quote item magento2 from controller

                    How to solve knockout JS error in Magento 2 Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?(Magento2) knockout.js:3012 Uncaught ReferenceError: Unable to process bindingUnable to process binding Knockout.js magento 2Cannot read property `scopeLabel` of undefined on Product Detail PageCan't get Customer Data on frontend in Magento 2Magento2 Order Summary - unable to process bindingKO templates are not loading in Magento 2.1 applicationgetting knockout js error magento 2Product grid not load -— Unable to process binding Knockout.js magento 2Product form not loaded in magento2Uncaught ReferenceError: Unable to process binding “if: function()return (isShowLegend()) ” magento 2

                    Nissan Patrol Зміст Перше покоління — 4W60 (1951-1960) | Друге покоління — 60 series (1960-1980) | Третє покоління (1980–2002) | Четверте покоління — Y60 (1987–1998) | П'яте покоління — Y61 (1997–2013) | Шосте покоління — Y62 (2010- ) | Посилання | Зноски | Навігаційне менюОфіційний український сайтТест-драйв Nissan Patrol 2010 7-го поколінняNissan PatrolКак мы тестировали Nissan Patrol 2016рвиправивши або дописавши її