লুপের জন্য সি ++ 11 ব্যাপ্তিতে থাকা অবস্থায় ভেক্টর থেকে আইটেমটি সরানো হচ্ছে?

Question 1

আমার কাছে IInventory * এর একটি ভেক্টর রয়েছে এবং আমি প্রতিটিের সাথে স্টাফ করার জন্য সি ++ 11 রেঞ্জ ব্যবহার করে তালিকার মধ্যে লুপ করছি।

একটি দিয়ে কিছু স্টাফ করার পরে, আমি এটি তালিকা থেকে মুছে ফেলতে এবং অবজেক্টটি মুছতে চাই। আমি জানি যে আমি deleteএটি পরিষ্কার করার জন্য যে কোনও সময় পয়েন্টারে কল করতে পারি , তবে পরিসর forলুপের মধ্যে থাকা অবস্থায় এটি ভেক্টর থেকে অপসারণ করার উপযুক্ত উপায় কী? এবং যদি আমি এটি তালিকা থেকে সরান তবে আমার লুপটি অবৈধ হবে?

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

for (IInventory* index : inv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
}

Question 2

না, আপনি পারবেন না। আপনার ধারকটির forপ্রতিটি উপাদান একবারে অ্যাক্সেস করার প্রয়োজন হলে রেঞ্জ-ভিত্তিক ।

আপনার forপাশাপাশি চলার সাথে সাথে ধারকটি পরিবর্তন করতে হবে, একবারে একাধিক উপাদান অ্যাক্সেস করতে হবে বা অন্যথায় ধারকটির মাধ্যমে একটি লিনিয়ার ফ্যাশনে পুনরাবৃত্তি করতে হবে তবে আপনার স্বাভাবিক লুপ বা এর কাজিনের একটি ব্যবহার করা উচিত ।

উদাহরণ স্বরূপ:

auto i = std::begin(inv);

while (i != std::end(inv)) {
    // Do some stuff
    if (blah)
        i = inv.erase(i);
    else
        ++i;
}

Question 3

প্রতিবার কোনও উপাদান ভেক্টর থেকে সরানো হলে, আপনাকে অবশ্যই মুছে ফেলা উপাদানটির বা তার পরে পুনরাবৃত্তিকে ধরে নিতে হবে না, কারণ মুছে ফেলা উপাদানগুলির উত্তরাধিকারী প্রতিটি উপাদান সরানো হয়েছে।

লুপের জন্য একটি পরিসীমা ভিত্তিক কেবল পুনরাবৃত্তকারীদের ব্যবহার করে "স্বাভাবিক" লুপের জন্য সিনট্যাকটিক চিনি, সুতরাং উপরেরটি প্রযোজ্য।

যা বলা হচ্ছে, আপনি কেবল:

inv.erase(
    std::remove_if(
        inv.begin(),
        inv.end(),
        [](IInventory* element) -> bool {
            // Do "some stuff", then return true if element should be removed.
            return true;
        }
    ),
    inv.end()
);

Question 4

এটির পুনরাবৃত্তি করার সময় আপনার আদর্শভাবে ভেক্টরটি সংশোধন করা উচিত নয়। মুছে ফেলা মুছুন ব্যবহার করুন। যদি আপনি এটি করেন তবে আপনার কয়েকটি সমস্যা দেখা দেওয়ার সম্ভাবনা রয়েছে। একটি যেহেতু vectorএকটি eraseঅকার্যকর করে সব iterators উপাদান দিয়ে শুরু পর্যন্ত মুছে ফেলা হচ্ছে end()আপনি ব্যবহার দ্বারা আপনার iterators বৈধ নিশ্চিত করতে হবে:

for (MyVector::iterator b = v.begin(); b != v.end();) { 
    if (foo) {
       b = v.erase( b ); // reseat iterator to a valid value post-erase
    else {
       ++b;
    }
}

দ্রষ্টব্য, আপনার b != v.end()যেমন পরীক্ষাটি প্রয়োজন তেমন। আপনি যদি নীচে এটি অপ্টিমাইজ করার চেষ্টা করেন:

for (MyVector::iterator b = v.begin(), e = v.end(); b != e;)

আপনার eপ্রথম eraseকলের পরে অবৈধ হওয়ার কারণে আপনি ইউবিতে চলে যাবেন ।

Question 5

সেই লুপে থাকা অবস্থায় উপাদানগুলি সরানো কি কঠোর প্রয়োজন? অন্যথায় আপনি যে পয়েন্টারগুলিকে NULL মুছতে চান সেটি সেট করে রাখতে এবং সমস্ত NULL পয়েন্টারগুলি সরাতে ভেক্টরের উপর দিয়ে আরেকটি পাস করতে পারেন।

std::vector<IInventory*> inv;
inv.push_back( new Foo() );
inv.push_back( new Bar() );

for ( IInventory* &index : inv )
{
    // do some stuff
    // ok I decided I need to remove this object from inv...?
    if (do_delete_index)
    {
        delete index;
        index = NULL;
    }
}
std::remove(inv.begin(), inv.end(), NULL);

Question 6

নেক্রোপোস্টিংয়ের জন্য দুঃখিত এবং আরও জানাচ্ছি যদি আমার সি ++ দক্ষতা আমার উত্তরের পথে আসে তবে আপনি যদি প্রতিটি আইটেমের মাধ্যমে পুনরাবৃত্তি করতে এবং সম্ভাব্য পরিবর্তনগুলি (সূচি মোছার মতো) করার চেষ্টা করেন তবে লুপের জন্য ব্যাকওয়ার্ড ব্যবহার করার চেষ্টা করুন।

for(int x=vector.getsize(); x>0; x--){

//do stuff
//erase index x

}

যখন সূচক x মুছে ফেলা হবে, পরবর্তী লুপটি আইটেমটির জন্য "শেষের" পুনরাবৃত্তির জন্য হবে। আমি সত্যিই আশা করি এটি কারও সাহায্য করেছে

Question 7

ঠিক আছে, আমি দেরি করে ফেলেছি, কিন্তু যাহাই হউক না কেন: দুঃখিত, না সঠিক আমি এতদূর যা পড়েন - এটা হল সম্ভব, আপনি শুধু দুই iterators প্রয়োজন:

std::vector<IInventory*>::iterator current = inv.begin();
for (IInventory* index : inv)
{
    if(/* ... */)
    {
        delete index;
    }
    else
    {
        *current++ = index;
    }
}
inv.erase(current, inv.end());

কেবল একটি পুনরাবৃত্তির নির্দেশিত মানটি কেবলমাত্র পরিবর্তন করে অন্য কোনও পুনরুক্তিকারীকে অকার্যকর করে না, তাই আমরা চিন্তা না করেই এটি করতে পারি। আসলে,std::remove_if (কমপক্ষে জিসিসি বাস্তবায়ন) খুব অনুরূপ কিছু করে (একটি ক্লাসিক লুপ ব্যবহার করে ...), কেবল কিছু মুছবে না এবং মুছবে না।

তবে সচেতন থাকুন যে এটি থ্রেড নিরাপদ নয় (!) - তবে এটি উপরের অন্যান্য সমাধানগুলির কয়েকটিতেও প্রযোজ্য ...

Question 8

আমি উদাহরণ সহ দেখাব, নীচের উদাহরণটি ভেক্টর থেকে বিজোড় উপাদানগুলি সরান:

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};

    //method 1
    for(auto it = vecInt.begin();it != vecInt.end();){
        if(*it % 2){// remove all the odds
            it = vecInt.erase(it);
        } else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 2
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 2
    for(auto it=std::begin(vecInt);it!=std::end(vecInt);){
        if (*it % 2){
            it = vecInt.erase(it);
        }else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 3
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 3
    vecInt.erase(std::remove_if(vecInt.begin(), vecInt.end(),
                 [](const int a){return a % 2;}),
                 vecInt.end());

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

}

নীচে আউটপুট আউট:

024
024
024

মনে রাখবেন, পদ্ধতিটি eraseপাস করা পুনরুদ্ধারকের পরবর্তী পুনরাবৃত্তিকে ফিরিয়ে দেবে।

থেকে এখানে , আমরা একটি আরো জেনারেট পদ্ধতি ব্যবহার করতে পারেন:

template<class Container, class F>
void erase_where(Container& c, F&& f)
{
    c.erase(std::remove_if(c.begin(), c.end(),std::forward<F>(f)),
            c.end());
}

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};
    //method 4
    auto is_odd = [](int x){return x % 2;};
    erase_where(vecInt, is_odd);

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;    
}

কিভাবে ব্যবহার করবেন তা দেখতে এখানে দেখুন std::remove_if । https://en.cppreferences.com/w/cpp/algorithm/remove

Question 9

এই থ্রেড শিরোনামের বিরোধিতা করে, আমি দুটি পাস ব্যবহার করব:

#include <algorithm>
#include <vector>

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

std::vector<IInventory*> toDelete;

for (IInventory* index : inv)
{
    // Do some stuff
    if (deleteConditionTrue)
    {
        toDelete.push_back(index);
    }
}

for (IInventory* index : toDelete)
{
    inv.erase(std::remove(inv.begin(), inv.end(), index), inv.end());
}

Question 10

এর থেকে আরও মার্জিত সমাধান std::listহ'ল (ধরে নেওয়া উচিত যে আপনার দ্রুত এলোমেলো অ্যাক্সেসের দরকার নেই)।

list<Widget*> widgets ; // create and use this..

তারপরে .remove_ifআপনি এক লাইনে সি ++ ফ্যাক্টর সহ মুছতে পারেন :

widgets.remove_if( []( Widget*w ){ return w->isExpired() ; } ) ;

সুতরাং এখানে আমি কেবল একটি ফান্টেক্টর লিখছি যা একটি যুক্তি (টি Widget*) গ্রহণ করে । রিটার্ন মান হ'ল শর্তটি যার উপর কWidget* থেকে তালিকা থেকে ।

আমি এই বাক্যবিন্যাসটি স্পষ্টতই খুঁজে পাই। আমি মনে করি না আমি কখনো ব্যবহার করেন remove_ifজন্য এসটিডি :: ভেক্টর - এত হয় inv.begin()এবং inv.end()গোলমাল আছে আপনি ব্যবহার বন্ধ সম্ভবত ভালো আছেন একটি পূর্ণসংখ্যা-সূচক ভিত্তিক ডিলিট বা শুধু একটি প্লেইন পুরোনো নিয়মিত পুনরুক্তিকারীর ভিত্তিক মুছে ফেলে (দেখানো হয়েছে নিচে). তবে আপনি যেভাবে std::vectorযাইহোক, খুব মাঝখানে থেকে সরানো উচিত নয় , তাই এlist তালিকা মুছে ফেলার প্রায়শই মাঝারি ক্ষেত্রে এই ক্ষেত্রে পরামর্শ দেওয়া হচ্ছে।

নোট কিন্তু আমি ফোন করার সুযোগ পান নি deleteউপর Widget*খামকা সরানো হয়েছে। এটি করার জন্য, এটি দেখতে এটির মতো হবে:

widgets.remove_if( []( Widget*w ){
  bool exp = w->isExpired() ;
  if( exp )  delete w ;       // delete the widget if it was expired
  return exp ;                // remove from widgets list if it was expired
} ) ;

আপনি নিয়মিত পুনরাবৃত্ত-ভিত্তিক লুপটি এর মতো ব্যবহার করতে পারেন:

//                                                              NO INCREMENT v
for( list<Widget*>::iterator iter = widgets.begin() ; iter != widgets.end() ; )
{
  if( (*iter)->isExpired() )
  {
    delete( *iter ) ;
    iter = widgets.erase( iter ) ; // _advances_ iter, so this loop is not infinite
  }
  else
    ++iter ;
}

আপনি যদি দৈর্ঘ্য পছন্দ না করেন তবে আপনি for( list<Widget*>::iterator iter = widgets.begin() ; ...ব্যবহার করতে পারেন

for( auto iter = widgets.begin() ; ...

Question 11

আমি মনে করি আমি নিম্নলিখিতগুলি করব ...

for (auto itr = inv.begin(); itr != inv.end();)
{
   // Do some stuff
   if (OK, I decided I need to remove this object from 'inv')
      itr = inv.erase(itr);
   else
      ++itr;
}

Question 12

আপনি লুপের পুনরাবৃত্তির সময় পুনরাবৃত্তিকে মুছতে পারবেন না কারণ পুনরাবৃত্তির গণনাটি মিলছে না এবং কিছু পুনরাবৃত্তির পরে আপনার অবৈধ পুনরাবৃত্তি হবে।

সমাধান: 1) মূল ভেক্টরের অনুলিপি নিন 2) এই অনুলিপিটি ব্যবহার করে পুনরুক্তি করুন 2) কিছু স্টাফ করুন এবং এটি আসল ভেক্টর থেকে মুছুন।

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

std::vector<IInventory*> copyinv = inv;
iteratorCout = 0;
for (IInventory* index : copyinv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
    inv.erase(inv.begin() + iteratorCout);
    iteratorCout++;
}

Question 13

একের পর এক উপাদান মোছা সহজেই N ^ 2 এর কার্যকারিতা নিয়ে যায়। মুছে ফেলা উচিত এমন উপাদানগুলি চিহ্নিত করা এবং লুপের পরে একবারে মুছে ফেলা ভাল। যদি আমি আপনার ভেক্টরে বৈধ উপাদান না হিসাবে নালপ্টার ধরে নিতে পারি, তবে

std::vector<IInventory*> inv;
// ... push some elements to inv
for (IInventory*& index : inv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
    {
      delete index;
      index =nullptr;
    }
}
inv.erase( std::remove( begin( inv ), end( inv ), nullptr ), end( inv ) );

কাজ করা উচিত.

আপনার "কিছু জিনিস করুন" যদি ভেক্টরের উপাদানগুলি পরিবর্তন না করে এবং কেবল উপাদানটি সরিয়ে ফেলতে বা রাখার সিদ্ধান্ত নিতে ব্যবহার করা হয় তবে আপনি এটিকে ল্যাম্বডায় রূপান্তর করতে পারেন (যেমন কারও আগের পোস্টে পরামর্শ দেওয়া হয়েছিল) এবং ব্যবহার করতে পারেন

inv.erase( std::remove_if( begin( inv ), end( inv ), []( Inventory* i )
  {
    // DO some stuff
    return OK, I decided I need to remove this object from 'inv'...
  } ), end( inv ) );