Can we increase the iterator without the 'advance' function? C++11

The name of the pictureThe name of the pictureThe name of the pictureClash Royale CLAN TAG#URR8PPP











up vote
6
down vote

favorite
1












I know we can use advance() function to increment the iterator. We also use iterator++ to increase the iterator by one position. Why we cannot use it+=2?



int main()

 list<int> l11, 2, 3, 5, 6;
 list<int> l22, 6, 8;
 auto it = l1.begin();
 advance(it, 2); //works
 it++; //works
 // it+=2; //not work
 l2.splice(l2.begin(), l1, it);

 for(int a: l2) cout<<a<<" ";
 cout<<endl;

 return 0;



You can run the above code here






c++ c++11 iterator listiterator







share|improve this question



















  • 5




    List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
    – William Lee
    3 hours ago











  • So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
    – moooeeeep
    2 hours ago















up vote
6
down vote

favorite
1












I know we can use advance() function to increment the iterator. We also use iterator++ to increase the iterator by one position. Why we cannot use it+=2?



int main()

 list<int> l11, 2, 3, 5, 6;
 list<int> l22, 6, 8;
 auto it = l1.begin();
 advance(it, 2); //works
 it++; //works
 // it+=2; //not work
 l2.splice(l2.begin(), l1, it);

 for(int a: l2) cout<<a<<" ";
 cout<<endl;

 return 0;



You can run the above code here






c++ c++11 iterator listiterator







share|improve this question



















  • 5




    List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
    – William Lee
    3 hours ago











  • So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
    – moooeeeep
    2 hours ago













up vote
6
down vote

favorite
1









up vote
6
down vote

favorite
1






1





I know we can use advance() function to increment the iterator. We also use iterator++ to increase the iterator by one position. Why we cannot use it+=2?



int main()

 list<int> l11, 2, 3, 5, 6;
 list<int> l22, 6, 8;
 auto it = l1.begin();
 advance(it, 2); //works
 it++; //works
 // it+=2; //not work
 l2.splice(l2.begin(), l1, it);

 for(int a: l2) cout<<a<<" ";
 cout<<endl;

 return 0;



You can run the above code here






c++ c++11 iterator listiterator







share|improve this question















I know we can use advance() function to increment the iterator. We also use iterator++ to increase the iterator by one position. Why we cannot use it+=2?



int main()

 list<int> l11, 2, 3, 5, 6;
 list<int> l22, 6, 8;
 auto it = l1.begin();
 advance(it, 2); //works
 it++; //works
 // it+=2; //not work
 l2.splice(l2.begin(), l1, it);

 for(int a: l2) cout<<a<<" ";
 cout<<endl;

 return 0;



You can run the above code here






c++ c++11 iterator listiterator




c++ c++11 iterator listiterator






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited 7 mins ago









Roger Lipscombe

54.8k39184305




54.8k39184305










asked 3 hours ago









Lusha Li

491




491







  • 5




    List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
    – William Lee
    3 hours ago











  • So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
    – moooeeeep
    2 hours ago













  • 5




    List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
    – William Lee
    3 hours ago











  • So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
    – moooeeeep
    2 hours ago








5




5




List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
– William Lee
3 hours ago





List has a bidirectional iterator, not a random access iterator. advance uses compile time machinery to optimize advance operation for different kinds of iterators.
– William Lee
3 hours ago













So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
– moooeeeep
2 hours ago





So your question is: "why wasn't operator+=() specified as syntactic sugar around std::advance()?" or is it really "why can't I use operator+=() here?"
– moooeeeep
2 hours ago













2 Answers
2






active

oldest

votes

















up vote
16
down vote













operator += is only supported by RandomAccessIterator; note that it's supposed to have constant complexity.



The iterator of std::list is BidirectionalIterator, which doesn't support operator +=. (The iterator of std::vector and std::array is RandomAccessIterator.)



Note that both of them could be used with std::advance, when used for RandomAccessIterator complexity is constant; when used for other InputIterators (including BidirectionalIterator) complexity is linear. That means using std::advance is a good idea because it's more general and could take advantage of the benefit of RandomAccessIterator automatically.






share|improve this answer





























    up vote
    7
    down vote













    You cannot use += 2 with this iterator because in general case incrementing std::list<> iterator by an arbitrary value is a relatively inefficient operation. += is not defined for your iterator type specifically to prevent you from carelessly/unknowingly using this inefficient operation in your code. Instead, if you really want to do that you are supposed to use std::advance, which is a "red flag" function that is intended to highlight the fact that you are likely doing something inefficient. std::advance is mostly intended for code sketching or for unlikely-to-get-executed fallback code. You are not supposed to use std::advance in real production code. If you suddenly find yourself relying on std::advance, it means that you probably need to redesign your data structures. Basically, std::advance is like a cast - you are not supposed to use it unless you have a very very very good reason to.



    Alternatively, you can use std::next



    it = std::next(it, 2);


    This function is much easier to use than std::advance. By default this function is designed to advance the iterator by 1 step forward, but you can specify the second parameter to move it farther. Again, when the value of second parameter is potentially large, it should be considered a "red flag" function. A constant value of 2 is definitely within acceptable bounds.






    share|improve this answer






















    • The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
      – WorldSEnder
      54 mins 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',
    convertImagesToLinks: true,
    noModals: false,
    showLowRepImageUploadWarning: true,
    reputationToPostImages: 10,
    bindNavPrevention: true,
    postfix: "",
    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%2f53002491%2fcan-we-increase-the-iterator-without-the-advance-function-c11%23new-answer', 'question_page');

    );

    Post as a guest

















    2 Answers
    2






    active

    oldest

    votes








    2 Answers
    2






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes








    up vote
    16
    down vote













    operator += is only supported by RandomAccessIterator; note that it's supposed to have constant complexity.



    The iterator of std::list is BidirectionalIterator, which doesn't support operator +=. (The iterator of std::vector and std::array is RandomAccessIterator.)



    Note that both of them could be used with std::advance, when used for RandomAccessIterator complexity is constant; when used for other InputIterators (including BidirectionalIterator) complexity is linear. That means using std::advance is a good idea because it's more general and could take advantage of the benefit of RandomAccessIterator automatically.






    share|improve this answer


























      up vote
      16
      down vote













      operator += is only supported by RandomAccessIterator; note that it's supposed to have constant complexity.



      The iterator of std::list is BidirectionalIterator, which doesn't support operator +=. (The iterator of std::vector and std::array is RandomAccessIterator.)



      Note that both of them could be used with std::advance, when used for RandomAccessIterator complexity is constant; when used for other InputIterators (including BidirectionalIterator) complexity is linear. That means using std::advance is a good idea because it's more general and could take advantage of the benefit of RandomAccessIterator automatically.






      share|improve this answer
























        up vote
        16
        down vote










        up vote
        16
        down vote









        operator += is only supported by RandomAccessIterator; note that it's supposed to have constant complexity.



        The iterator of std::list is BidirectionalIterator, which doesn't support operator +=. (The iterator of std::vector and std::array is RandomAccessIterator.)



        Note that both of them could be used with std::advance, when used for RandomAccessIterator complexity is constant; when used for other InputIterators (including BidirectionalIterator) complexity is linear. That means using std::advance is a good idea because it's more general and could take advantage of the benefit of RandomAccessIterator automatically.






        share|improve this answer














        operator += is only supported by RandomAccessIterator; note that it's supposed to have constant complexity.



        The iterator of std::list is BidirectionalIterator, which doesn't support operator +=. (The iterator of std::vector and std::array is RandomAccessIterator.)



        Note that both of them could be used with std::advance, when used for RandomAccessIterator complexity is constant; when used for other InputIterators (including BidirectionalIterator) complexity is linear. That means using std::advance is a good idea because it's more general and could take advantage of the benefit of RandomAccessIterator automatically.







        share|improve this answer














        share|improve this answer



        share|improve this answer








        edited 3 hours ago

























        answered 3 hours ago









        songyuanyao

        86.8k10167228




        86.8k10167228






















            up vote
            7
            down vote













            You cannot use += 2 with this iterator because in general case incrementing std::list<> iterator by an arbitrary value is a relatively inefficient operation. += is not defined for your iterator type specifically to prevent you from carelessly/unknowingly using this inefficient operation in your code. Instead, if you really want to do that you are supposed to use std::advance, which is a "red flag" function that is intended to highlight the fact that you are likely doing something inefficient. std::advance is mostly intended for code sketching or for unlikely-to-get-executed fallback code. You are not supposed to use std::advance in real production code. If you suddenly find yourself relying on std::advance, it means that you probably need to redesign your data structures. Basically, std::advance is like a cast - you are not supposed to use it unless you have a very very very good reason to.



            Alternatively, you can use std::next



            it = std::next(it, 2);


            This function is much easier to use than std::advance. By default this function is designed to advance the iterator by 1 step forward, but you can specify the second parameter to move it farther. Again, when the value of second parameter is potentially large, it should be considered a "red flag" function. A constant value of 2 is definitely within acceptable bounds.






            share|improve this answer






















            • The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
              – WorldSEnder
              54 mins ago














            up vote
            7
            down vote













            You cannot use += 2 with this iterator because in general case incrementing std::list<> iterator by an arbitrary value is a relatively inefficient operation. += is not defined for your iterator type specifically to prevent you from carelessly/unknowingly using this inefficient operation in your code. Instead, if you really want to do that you are supposed to use std::advance, which is a "red flag" function that is intended to highlight the fact that you are likely doing something inefficient. std::advance is mostly intended for code sketching or for unlikely-to-get-executed fallback code. You are not supposed to use std::advance in real production code. If you suddenly find yourself relying on std::advance, it means that you probably need to redesign your data structures. Basically, std::advance is like a cast - you are not supposed to use it unless you have a very very very good reason to.



            Alternatively, you can use std::next



            it = std::next(it, 2);


            This function is much easier to use than std::advance. By default this function is designed to advance the iterator by 1 step forward, but you can specify the second parameter to move it farther. Again, when the value of second parameter is potentially large, it should be considered a "red flag" function. A constant value of 2 is definitely within acceptable bounds.






            share|improve this answer






















            • The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
              – WorldSEnder
              54 mins ago












            up vote
            7
            down vote










            up vote
            7
            down vote









            You cannot use += 2 with this iterator because in general case incrementing std::list<> iterator by an arbitrary value is a relatively inefficient operation. += is not defined for your iterator type specifically to prevent you from carelessly/unknowingly using this inefficient operation in your code. Instead, if you really want to do that you are supposed to use std::advance, which is a "red flag" function that is intended to highlight the fact that you are likely doing something inefficient. std::advance is mostly intended for code sketching or for unlikely-to-get-executed fallback code. You are not supposed to use std::advance in real production code. If you suddenly find yourself relying on std::advance, it means that you probably need to redesign your data structures. Basically, std::advance is like a cast - you are not supposed to use it unless you have a very very very good reason to.



            Alternatively, you can use std::next



            it = std::next(it, 2);


            This function is much easier to use than std::advance. By default this function is designed to advance the iterator by 1 step forward, but you can specify the second parameter to move it farther. Again, when the value of second parameter is potentially large, it should be considered a "red flag" function. A constant value of 2 is definitely within acceptable bounds.






            share|improve this answer














            You cannot use += 2 with this iterator because in general case incrementing std::list<> iterator by an arbitrary value is a relatively inefficient operation. += is not defined for your iterator type specifically to prevent you from carelessly/unknowingly using this inefficient operation in your code. Instead, if you really want to do that you are supposed to use std::advance, which is a "red flag" function that is intended to highlight the fact that you are likely doing something inefficient. std::advance is mostly intended for code sketching or for unlikely-to-get-executed fallback code. You are not supposed to use std::advance in real production code. If you suddenly find yourself relying on std::advance, it means that you probably need to redesign your data structures. Basically, std::advance is like a cast - you are not supposed to use it unless you have a very very very good reason to.



            Alternatively, you can use std::next



            it = std::next(it, 2);


            This function is much easier to use than std::advance. By default this function is designed to advance the iterator by 1 step forward, but you can specify the second parameter to move it farther. Again, when the value of second parameter is potentially large, it should be considered a "red flag" function. A constant value of 2 is definitely within acceptable bounds.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 3 hours ago

























            answered 3 hours ago









            AnT

            254k31404651




            254k31404651











            • The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
              – WorldSEnder
              54 mins ago
















            • The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
              – WorldSEnder
              54 mins ago















            The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
            – WorldSEnder
            54 mins ago




            The reason that += is associated with a constant time operation, is possibly because pointers are normally the first iterator type that one is introduced to and naturally supports pointer arithmetic from its c legacy - just neat to understand that this interface design was more or less forced onto c++ by existing culture.
            – WorldSEnder
            54 mins ago

















             

            draft saved


            draft discarded















































             


            draft saved


            draft discarded














            StackExchange.ready(
            function ()
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53002491%2fcan-we-increase-the-iterator-without-the-advance-function-c11%23new-answer', 'question_page');

            );

            Post as a guest
































































            Comments

            Post a Comment

            Popular posts from this blog

            What does second last employer means? [closed]

            Image
            Clash Royale CLAN TAG #URR8PPP .everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty margin-bottom:0; up vote -3 down vote favorite Say, for example I have worked in the following companies, Company A => 2010 - 2011 Company B => 2011 - 2012 Company C => 2012 - Till Date Company D => Have offer Now assume Company D is asking to submit documents from my second last employer. So from the list of companies given, which company would be qualified as second last employer? software-industry employer share | improve this question asked Aug 10 '14 at 5:16 Rajaprabhu Aravindasamy 559 1 6 13 closed as off-topic by Jim G., jmort253 ♦ Aug 11 '14 at 1:58 This question appears to be off-topic. The users who voted to close gave this specific reason: "Questions seeking advice on company-specific regulations, agreements, or policies should be directed to your manager or HR department. Questions that address...
            Read more

            List of Gilmore Girls characters

            Image
            The season three cast—(Back row): Lane, Michel, Paris, Emily, Richard, Sookie, Miss Patty, Kirk; Front row: Jess, Luke, Lorelai, Rory, Dean This is a list of characters for the comedy-drama television series Gilmore Girls . Contents 1 Main characters 1.1 Lorelai Gilmore 1.2 Rory Gilmore 1.3 Sookie St. James 1.4 Lane Kim 1.5 Michel Gerard 1.6 Luke Danes 1.7 Emily Gilmore 1.8 Richard Gilmore 1.9 Paris Geller 1.10 Dean Forester 1.11 Jess Mariano 1.12 Kirk Gleason 1.13 Jason Stiles 1.14 Logan Huntzberger 2 Major recurring characters 2.1 Christopher Hayden 2.2 Jackson Belleville 2.3 Mrs. Kim 2.4 Tristin DuGray 2.5 Max Medina 2.6 Taylor Doose 2.7 Dave Rygalski 2.8 Marty 3 Recurring characters 3.1 Stars Hollow 3.2 Chilton 3.3 Yale 3.4 Other 4 Notable guest stars 5 Unseen characters 6 Notes 7 References Main characters Actor Character Appearances Season 1 Season 2 Season 3 Season 4 Season 5 Season 6 Season 7 A Year in the Life Lauren Graham Lorelai Gilmore...
            Read more

            Confectionery

            Image
            Prepared foods made with a lot of sugar or other cabohydrates "Sweetmeat" redirects here. For the racehorse, see Sweetmeat (horse). Not to be confused with Sweetbread. This Kransekake is a traditional Scandinavian baker's confection. Confectionery is the art of making confections , which are food items that are rich in sugar and carbohydrates. Exact definitions are difficult. [1] In general, though, confectionery is divided into two broad and somewhat overlapping categories, bakers' confections and sugar confections. [2] Bakers' confectionery, also called flour confections , includes principally sweet pastries, cakes, and similar baked goods. Sugar confectionery includes candies ( sweets in British English), candied nuts, chocolates, chewing gum, bubble gum, pastillage, and other confections that are made primarily of sugar. In some cases, chocolate confections (confections made of chocolate) are treated as a separate category, as are sugar-free versions of ...
            Read more