What's the difference between `auto pp` and `auto *ppp`?












20














int foo = 11;

int *p = &foo;



auto pp = p;

auto *ppp = p;



cout << pp << endl;

cout << ppp << endl;


This program will produce the same output for pp and ppp, but why? auto deduces the variable should be int, so I think the declaration of ppp is right. But pp and ppp have the same value...



Output:



0x61fefc

0x61fefc





c++ c++11 pointers auto







share|improve this question





























    20














    int foo = 11;
    
int *p = &foo;
    

    
auto pp = p;
    
auto *ppp = p;
    

    
cout << pp << endl;
    
cout << ppp << endl;


    This program will produce the same output for pp and ppp, but why? auto deduces the variable should be int, so I think the declaration of ppp is right. But pp and ppp have the same value...



    Output:



    0x61fefc
    
0x61fefc





    c++ c++11 pointers auto







    share|improve this question



























      20












      20








      20


      4





      int foo = 11;
      
int *p = &foo;
      

      
auto pp = p;
      
auto *ppp = p;
      

      
cout << pp << endl;
      
cout << ppp << endl;


      This program will produce the same output for pp and ppp, but why? auto deduces the variable should be int, so I think the declaration of ppp is right. But pp and ppp have the same value...



      Output:



      0x61fefc
      
0x61fefc





      c++ c++11 pointers auto







      share|improve this question















      int foo = 11;
      
int *p = &foo;
      

      
auto pp = p;
      
auto *ppp = p;
      

      
cout << pp << endl;
      
cout << ppp << endl;


      This program will produce the same output for pp and ppp, but why? auto deduces the variable should be int, so I think the declaration of ppp is right. But pp and ppp have the same value...



      Output:



      0x61fefc
      
0x61fefc





      c++ c++11 pointers auto




      c++ c++11 pointers auto






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Nov 29 at 17:40









      Boann

      36.7k1287121




      36.7k1287121










      asked Nov 29 at 10:50









      廖茂生

      1329




      1329
























          2 Answers
          2






          active

          oldest

          votes


















          29














          In the particular example you show, there is no difference. But imagine you would later on add two const qualifier like the following:



          const auto pp = p;
          
const auto *ppp = p;


          Is it still the same? Turns out that this is identical to



          int * const pp = p; // pointer is readonly
          
const int *ppp = p; // pointer is readonly


          because in auto pp = p, auto matches int* as a whole, and const modifies what's on its left (or what's on its right, if there is nothing on its left). Contrary, in auto *ppp = p, auto matches int, and this is what const applies to.



          Because of this notable difference and because we should use const variables whenever possible, I'd advise you to always use auto* when using type deduction for pointer variables. There is no way to const-qualify the pointer itself instead of the pointee, and if you want to const-qualify both, this is possible by



          const auto * const pppp = p;


          which doesn't work without the *.






          share|improve this answer























          • Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
            – davidbak
            Nov 29 at 15:10










          • Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
            – Ruslan
            Nov 29 at 15:13










          • @Ruslan You're right, I'll improve the wording.
            – lubgr
            Nov 29 at 15:13






          • 2




            @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
            – lubgr
            Nov 29 at 15:14








          • 2




            Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
            – Scheff
            Nov 30 at 9:12



















          7














          There is no difference in auto and auto * in this particular case. In case of auto pp = p; type will be deduced to int * while in case of auto *ppp = p; type will be deduced to int.



          auto qualifier:




          For variables, specifies that the type of the variable that is being declared will be automatically deduced from its initializer. [...]




          Note that unlike auto the auto * will deduce only pointer types.






          share|improve this answer



















          • 6




            The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
            – rustyx
            Nov 29 at 10:58










          • @rustyx; I added particular case.
            – haccks
            Nov 29 at 11:00











          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%2f53537326%2fwhats-the-difference-between-auto-pp-and-auto-ppp%23new-answer', 'question_page');
          }
          );

          Post as a guest















          Required, but never shown

























          2 Answers
          2






          active

          oldest

          votes








          2 Answers
          2






          active

          oldest

          votes









          active

          oldest

          votes






          active

          oldest

          votes









          29














          In the particular example you show, there is no difference. But imagine you would later on add two const qualifier like the following:



          const auto pp = p;
          
const auto *ppp = p;


          Is it still the same? Turns out that this is identical to



          int * const pp = p; // pointer is readonly
          
const int *ppp = p; // pointer is readonly


          because in auto pp = p, auto matches int* as a whole, and const modifies what's on its left (or what's on its right, if there is nothing on its left). Contrary, in auto *ppp = p, auto matches int, and this is what const applies to.



          Because of this notable difference and because we should use const variables whenever possible, I'd advise you to always use auto* when using type deduction for pointer variables. There is no way to const-qualify the pointer itself instead of the pointee, and if you want to const-qualify both, this is possible by



          const auto * const pppp = p;


          which doesn't work without the *.






          share|improve this answer























          • Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
            – davidbak
            Nov 29 at 15:10










          • Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
            – Ruslan
            Nov 29 at 15:13










          • @Ruslan You're right, I'll improve the wording.
            – lubgr
            Nov 29 at 15:13






          • 2




            @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
            – lubgr
            Nov 29 at 15:14








          • 2




            Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
            – Scheff
            Nov 30 at 9:12
















          29














          In the particular example you show, there is no difference. But imagine you would later on add two const qualifier like the following:



          const auto pp = p;
          
const auto *ppp = p;


          Is it still the same? Turns out that this is identical to



          int * const pp = p; // pointer is readonly
          
const int *ppp = p; // pointer is readonly


          because in auto pp = p, auto matches int* as a whole, and const modifies what's on its left (or what's on its right, if there is nothing on its left). Contrary, in auto *ppp = p, auto matches int, and this is what const applies to.



          Because of this notable difference and because we should use const variables whenever possible, I'd advise you to always use auto* when using type deduction for pointer variables. There is no way to const-qualify the pointer itself instead of the pointee, and if you want to const-qualify both, this is possible by



          const auto * const pppp = p;


          which doesn't work without the *.






          share|improve this answer























          • Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
            – davidbak
            Nov 29 at 15:10










          • Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
            – Ruslan
            Nov 29 at 15:13










          • @Ruslan You're right, I'll improve the wording.
            – lubgr
            Nov 29 at 15:13






          • 2




            @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
            – lubgr
            Nov 29 at 15:14








          • 2




            Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
            – Scheff
            Nov 30 at 9:12














          29












          29








          29






          In the particular example you show, there is no difference. But imagine you would later on add two const qualifier like the following:



          const auto pp = p;
          
const auto *ppp = p;


          Is it still the same? Turns out that this is identical to



          int * const pp = p; // pointer is readonly
          
const int *ppp = p; // pointer is readonly


          because in auto pp = p, auto matches int* as a whole, and const modifies what's on its left (or what's on its right, if there is nothing on its left). Contrary, in auto *ppp = p, auto matches int, and this is what const applies to.



          Because of this notable difference and because we should use const variables whenever possible, I'd advise you to always use auto* when using type deduction for pointer variables. There is no way to const-qualify the pointer itself instead of the pointee, and if you want to const-qualify both, this is possible by



          const auto * const pppp = p;


          which doesn't work without the *.






          share|improve this answer














          In the particular example you show, there is no difference. But imagine you would later on add two const qualifier like the following:



          const auto pp = p;
          
const auto *ppp = p;


          Is it still the same? Turns out that this is identical to



          int * const pp = p; // pointer is readonly
          
const int *ppp = p; // pointer is readonly


          because in auto pp = p, auto matches int* as a whole, and const modifies what's on its left (or what's on its right, if there is nothing on its left). Contrary, in auto *ppp = p, auto matches int, and this is what const applies to.



          Because of this notable difference and because we should use const variables whenever possible, I'd advise you to always use auto* when using type deduction for pointer variables. There is no way to const-qualify the pointer itself instead of the pointee, and if you want to const-qualify both, this is possible by



          const auto * const pppp = p;


          which doesn't work without the *.







          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Dec 6 at 8:00









          gsamaras

          50.5k2399185




          50.5k2399185










          answered Nov 29 at 11:33









          lubgr

          10.2k21745




          10.2k21745












          • Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
            – davidbak
            Nov 29 at 15:10










          • Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
            – Ruslan
            Nov 29 at 15:13










          • @Ruslan You're right, I'll improve the wording.
            – lubgr
            Nov 29 at 15:13






          • 2




            @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
            – lubgr
            Nov 29 at 15:14








          • 2




            Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
            – Scheff
            Nov 30 at 9:12


















          • Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
            – davidbak
            Nov 29 at 15:10










          • Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
            – Ruslan
            Nov 29 at 15:13










          • @Ruslan You're right, I'll improve the wording.
            – lubgr
            Nov 29 at 15:13






          • 2




            @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
            – lubgr
            Nov 29 at 15:14








          • 2




            Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
            – Scheff
            Nov 30 at 9:12
















          Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
          – davidbak
          Nov 29 at 15:10




          Subtle, and important to know, and I don't recall reading this in any recent C++ book, e.g., Stroustrup's Tour 2nd ed. (I may have missed it.)
          – davidbak
          Nov 29 at 15:10












          Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
          – Ruslan
          Nov 29 at 15:13




          Actually you didn't add const qualifier to both variables. You instead added it to the first variable and to the pointee of the second one.
          – Ruslan
          Nov 29 at 15:13












          @Ruslan You're right, I'll improve the wording.
          – lubgr
          Nov 29 at 15:13




          @Ruslan You're right, I'll improve the wording.
          – lubgr
          Nov 29 at 15:13




          2




          2




          @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
          – lubgr
          Nov 29 at 15:14






          @davidbak I agree, this is not super obvious. It bit me once, and as painful learning is quite effective, I remember since then :)
          – lubgr
          Nov 29 at 15:14






          2




          2




          Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
          – Scheff
          Nov 30 at 9:12




          Yepppp! Painful learning is quite effective but unfortunately time consuming (and sometimes frustrating). Reading a nice explanation (making things obvious) is the 2nd best option (and much less time consuming).
          – Scheff
          Nov 30 at 9:12













          7














          There is no difference in auto and auto * in this particular case. In case of auto pp = p; type will be deduced to int * while in case of auto *ppp = p; type will be deduced to int.



          auto qualifier:




          For variables, specifies that the type of the variable that is being declared will be automatically deduced from its initializer. [...]




          Note that unlike auto the auto * will deduce only pointer types.






          share|improve this answer



















          • 6




            The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
            – rustyx
            Nov 29 at 10:58










          • @rustyx; I added particular case.
            – haccks
            Nov 29 at 11:00
















          7














          There is no difference in auto and auto * in this particular case. In case of auto pp = p; type will be deduced to int * while in case of auto *ppp = p; type will be deduced to int.



          auto qualifier:




          For variables, specifies that the type of the variable that is being declared will be automatically deduced from its initializer. [...]




          Note that unlike auto the auto * will deduce only pointer types.






          share|improve this answer



















          • 6




            The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
            – rustyx
            Nov 29 at 10:58










          • @rustyx; I added particular case.
            – haccks
            Nov 29 at 11:00














          7












          7








          7






          There is no difference in auto and auto * in this particular case. In case of auto pp = p; type will be deduced to int * while in case of auto *ppp = p; type will be deduced to int.



          auto qualifier:




          For variables, specifies that the type of the variable that is being declared will be automatically deduced from its initializer. [...]




          Note that unlike auto the auto * will deduce only pointer types.






          share|improve this answer














          There is no difference in auto and auto * in this particular case. In case of auto pp = p; type will be deduced to int * while in case of auto *ppp = p; type will be deduced to int.



          auto qualifier:




          For variables, specifies that the type of the variable that is being declared will be automatically deduced from its initializer. [...]




          Note that unlike auto the auto * will deduce only pointer types.







          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Nov 29 at 17:49

























          answered Nov 29 at 10:52









          haccks

          85.6k20126218




          85.6k20126218








          • 6




            The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
            – rustyx
            Nov 29 at 10:58










          • @rustyx; I added particular case.
            – haccks
            Nov 29 at 11:00














          • 6




            The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
            – rustyx
            Nov 29 at 10:58










          • @rustyx; I added particular case.
            – haccks
            Nov 29 at 11:00








          6




          6




          The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
          – rustyx
          Nov 29 at 10:58




          The key point is auto uses template argument deduction rules, and so auto* will only deduce pointer types.
          – rustyx
          Nov 29 at 10:58












          @rustyx; I added particular case.
          – haccks
          Nov 29 at 11:00




          @rustyx; I added particular case.
          – haccks
          Nov 29 at 11:00


















          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.





          Some of your past answers have not been well-received, and you're in danger of being blocked from answering.


          Please pay close attention to the following guidance:


          • 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%2f53537326%2fwhats-the-difference-between-auto-pp-and-auto-ppp%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

          Wiesbaden

          Image
          Wappen Deutschlandkarte 50.0825 8.24 117 Koordinaten: 50° 5′  N , 8° 14′  O Basisdaten Bundesland: Hessen Regierungsbezirk: Darmstadt Höhe: 117 m ü. NHN Fläche: 203,93 km 2 Einwohner: 278.654 (31. Dez. 2017) [1] Bevölkerungsdichte: 1366 Einwohner je km 2 Postleitzahlen: 65183–65207, 55246, 55252 Vorlage:Infobox Gemeinde in Deutschland/Wartung/PLZ enthält Text Vorwahlen: 0611, 06122, 06127, 06134 Kfz-Kennzeichen: WI Gemeindeschlüssel: 06 4 14 000 LOCODE: DE WIB NUTS: DE714 Stadtgliederung: 26 Ortsbezirke Adresse der Stadtverwaltung: Schlossplatz 6 65183 Wiesbaden Webpräsenz: www.wiesbaden.de Oberbürgermeister: Sven Gerich (SPD) Lage der Landeshauptstadt Wiesbaden in Hessen und im Regierungsbezirk Darmstadt Offizielles Logo der Landeshauptstadt Wiesbaden Flagge der Landeshauptstadt Wiesbaden Wiesbaden is
          Read more

          Marschland

          Image
          Kilometerweite Marsch in den Vier- und Marschlanden am Elbdeich Die Wedeler Marschlandschaft in Schleswig-Holstein Der Hadelner Kanal zur Entwässerung der Marsch Die tief gelegene Marsch und ein Entwässerungskanal Das Schöpfwerk Otterndorf im Land Hadeln zur Entwässerung der Medem verfügte damals bereits über die größte Kreiselpumpe Europas. Das Schöpfwerk in Neuhaus für die Aue und des Neuhaus-Bülkauer Kanals Als Marsch(land) (v. niederdt., altsächs. mersc ) – auch Masch , Mersch oder Schwemmland genannt – bezeichnet man eine nacheiszeitlich entstandene geomorphologische Landform im Gebiet der nordwestdeutschen Küsten und Flüsse sowie vergleichbare Landformen weltweit. Inhaltsverzeichnis 1 Landschaft 2 Entstehung 3 Marschböden 4 Nutzung 5 Marschgebiete in Deutschland 6 Siehe auch 7 Literatur 8 Weblinks 9 Einzelnachweise Landschaft | Marschen sind generell flache Landstriche ohne natürliche Erhebungen. Si
          Read more

          Dieringhausen

          Image
          Dieringhausen Stadt Gummersbach 50.982777777778 7.5316666666667 165 Koordinaten: 50° 58′ 58″  N , 7° 31′ 54″  O Höhe: 165  (160–245)  m Einwohner: 5055  (30. Jun. 2016) Postleitzahl: 51645 Vorwahl: 02261 Lage von Dieringhausen in Gummersbach Im Hohl ca. 1927–1930 Ansicht von Südwesten bei Bünghausen Dieringhausen (im örtlichen Dialekt Dierkesen ) ist ein Ortsteil von Gummersbach im Oberbergischen Kreis, Regierungsbezirk Köln, Nordrhein-Westfalen (Deutschland). Inhaltsverzeichnis 1 Geographie 2 Geschichte 3 Kultur 3.1 Sehenswürdigkeiten 3.2 Regelmäßige Veranstaltungen 4 Infrastruktur und Wirtschaft 4.1 Verkehr 4.1.1 Schienen- und Busverkehr 4.1.2 Straßen 4.2 Öffentliche Einrichtungen 4.2.1 Schulen und Bildungseinrichtungen 4.2.2 Kirchliche Einrichtungen 5 Persönlichkeiten 5.1 In Dieringhausen geboren 5.2 In Dieringhausen gelebt 6 Einzelnachweise 7
          Read more