লুপগুলির জন্য এটি কি সি ++ 11 এর একটি পরিচিত সমস্যা?

Question 1

আসুন কল্পনা করুন আমাদের কিছু সদস্য ফাংশন সহ 3 ডাবল রাখার জন্য একটি কাঠামো রয়েছে:

struct Vector {
  double x, y, z;
  // ...
  Vector &negate() {
    x = -x; y = -y; z = -z;
    return *this;
  }
  Vector &normalize() {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  // ...
};

এটি সরলতার জন্য কিছুটা স্বীকৃত, তবে আমি নিশ্চিত যে আপনি সম্মত হন যে অনুরূপ কোডটি এখানে রয়েছে। পদ্ধতিগুলি আপনাকে সুবিধার্থে চেইন করতে দেয়, উদাহরণস্বরূপ:

Vector v = ...;
v.normalize().negate();

অথবা এমনকি:

Vector v = Vector{1., 2., 3.}.normalize().negate();

এখন যদি আমরা শুরু () এবং শেষ () ফাংশন সরবরাহ করি তবে আমরা আমাদের ভেক্টরকে লুপের জন্য একটি নতুন স্টাইলে ব্যবহার করতে পারি, 3 টি স্থানাঙ্ক x, y এবং z এর উপর লুপ করতে বলতে পারি (আপনি সন্দেহাতীতভাবে আরও "দরকারী" উদাহরণ তৈরি করতে পারবেন না ভেক্টরকে উদাহরণস্বরূপ স্ট্রিং দিয়ে প্রতিস্থাপন করে):

Vector v = ...;
for (double x : v) { ... }

আমরা এমনকি করতে পারেন:

Vector v = ...;
for (double x : v.normalize().negate()) { ... }

এবং আরো:

for (double x : Vector{1., 2., 3.}) { ... }

তবে, নিম্নলিখিতগুলি (এটি আমার কাছে মনে হচ্ছে) নষ্ট হয়েছে:

for (double x : Vector{1., 2., 3.}.normalize()) { ... }

এটি আগের দুটি ব্যবহারের যৌক্তিক সংমিশ্রণের মতো মনে হলেও, আমি মনে করি এই শেষ ব্যবহারটি একটি ঝুঁকির রেফারেন্স তৈরি করে যখন আগের দুটি সম্পূর্ণ সূক্ষ্ম।

এটি কি সঠিক এবং ব্যাপকভাবে প্রশংসিত?
উপরের কোন অংশটি "খারাপ" অংশ, তা এড়ানো উচিত?
লুপটির জন্য পরিসর-ভিত্তিক সংজ্ঞা পরিবর্তনের মাধ্যমে ভাষার উন্নতি হবে যে লুপের সময়কালের জন্য প্রকাশের জন্য তৈরি টেম্পোরারিগুলি বিদ্যমান?

Question 2

এটি কি সঠিক এবং ব্যাপকভাবে প্রশংসিত?

হ্যাঁ, আপনার জিনিসগুলি সম্পর্কে সঠিক ধারণা রয়েছে।

উপরের কোন অংশটি "খারাপ" অংশ, তা এড়ানো উচিত?

খারাপ অংশটি কোনও ফাংশন থেকে ফিরে আসা অস্থায়ীটির জন্য একটি এল-মান রেফারেন্স নিচ্ছে এবং এটি কোনও আর-মান রেফারেন্সে আবদ্ধ করবে। এটি এর মতোই খারাপ:

auto &&t = Vector{1., 2., 3.}.normalize();

অস্থায়ী Vector{1., 2., 3.}জীবনকাল বাড়ানো যায় না কারণ সংকলকটির কোনও ধারণা নেই যে normalizeএটির থেকে ফেরতের মান এটি উল্লেখ করে।

লুপটির জন্য পরিসর-ভিত্তিক সংজ্ঞা পরিবর্তনের মাধ্যমে ভাষার উন্নতি হবে যে লুপের সময়কালের জন্য প্রকাশের জন্য তৈরি টেম্পোরারিগুলি বিদ্যমান?

এটি সি ++ কীভাবে কাজ করে তার সাথে অত্যন্ত বেমানান।

এটি কি অস্থায়ীভাবে বা অভিব্যক্তির জন্য বিভিন্ন অলস-মূল্যায়নের পদ্ধতিতে শৃঙ্খলাবদ্ধ অভিব্যক্তি ব্যবহার করে লোকেদের দ্বারা তৈরি কিছু গ্যাচগুলি প্রতিরোধ করবে? হ্যাঁ. তবে এটির জন্য বিশেষ-কেস সংকলক কোডেরও প্রয়োজন হবে, পাশাপাশি বিভ্রান্ত হবেন যে কেন এটি অন্যান্য অভিব্যক্তি নির্মাণের সাথে কাজ করে না ।

একটি আরও যুক্তিসঙ্গত সমাধান সংকলককে অবহিত করার কিছু উপায় হতে পারে যে কোনও ফাংশনের রিটার্ন মান সর্বদা একটি উল্লেখ thisis যদিও এটি একটি ভাষা-স্তরের সমাধান।

বর্তমানে (যদি সংকলক এটি সমর্থন করে), আপনি এটি তৈরি করতে পারেন যাতে অস্থায়ীভাবে ডাকা যায় normalize না :

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector &normalize() && = delete;
};

এটি Vector{1., 2., 3.}.normalize()একটি সংকলন ত্রুটি দেবে, ঠিক আছে যখন v.normalize()কাজ করবে। স্পষ্টতই আপনি এই জাতীয় সঠিক জিনিস করতে সক্ষম হবেন না:

Vector t = Vector{1., 2., 3.}.normalize();

তবে আপনিও ভুল জিনিস করতে পারবেন না।

বিকল্প হিসাবে, মন্তব্যে প্রস্তাবিত হিসাবে, আপনি মূল্যের রেফারেন্স সংস্করণটিকে কোনও রেফারেন্সের পরিবর্তে কোনও মান ফিরিয়ে দিতে পারেন:

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector normalize() && {
     Vector ret = *this;
     ret.normalize();
     return ret;
  }
};

যদি Vectorপ্রকৃত সম্পদ সঙ্গে একটি টাইপ সরাতে ছিল, আপনি ব্যবহার করতে পারে Vector ret = std::move(*this);পরিবর্তে। নামযুক্ত রিটার্ন মান অপ্টিমাইজেশন পারফরম্যান্সের ক্ষেত্রে এটি যথাযথভাবে অনুকূল করে তোলে।

Question 3

(ডাবল এক্স: ভেক্টর {1।, 2., 3। normal। স্বাভাবিককরণ ()) {...}

এটি ভাষার সীমাবদ্ধতা নয়, তবে আপনার কোড নিয়ে সমস্যা। অভিব্যক্তিটি Vector{1., 2., 3.}একটি অস্থায়ী তৈরি করে তবে normalizeফাংশনটি একটি মূল্য-রেফারেন্স দেয় । যেহেতু অভিব্যক্তিটি একটি মূল্যমান , সংকলকটি ধরে নেয় যে বস্তুটি জীবিত থাকবে, তবে এটি একটি অস্থায়ী সম্পর্কিত কারণ হিসাবে সম্পূর্ণ অভিব্যক্তিটি মূল্যায়নের পরে অবজেক্টটি মারা যায়, সুতরাং আপনার ঝুঁকির উল্লেখ রয়েছে।

এখন, আপনি যদি বর্তমান ডিজাইনের পরিবর্তে মান দ্বারা কোনও নতুন অবজেক্ট ফিরিয়ে দিতে আপনার ডিজাইনটি পরিবর্তন করেন তবে কোনও সমস্যা হবে না এবং কোডটি প্রত্যাশা অনুযায়ী কাজ করবে।

Question 4

আইএমএইচও, দ্বিতীয় উদাহরণটি ইতিমধ্যে ত্রুটিযুক্ত। পরিবর্তিত অপারেটররা ফিরে আসার *thisবিষয়টি আপনি যেভাবে উল্লেখ করেছেন তাতে সুবিধাজনক: এটি সংশোধনকারীদের শৃঙ্খলার অনুমতি দেয়। এটি কেবলমাত্র পরিবর্তনের ফলাফলটি হস্তান্তর করার জন্য ব্যবহার করা যেতে পারে তবে এটি করা ত্রুটি-প্রবণ কারণ এটি সহজেই উপেক্ষা করা যায়। আমি যদি কিছু দেখতে পাই

Vector v{1., 2., 3.};
auto foo = somefunction1(v, 17);
auto bar = somefunction2(true, v, 2, foo);
auto baz = somefunction3(bar.quun(v), 93.2, v.qwarv(foo));

আমি স্বয়ংক্রিয়ভাবে সন্দেহ করব না যে কার্যগুলি vপার্শ্ব-প্রতিক্রিয়া হিসাবে পরিবর্তন করে । অবশ্যই, তারা পারে , কিন্তু এটি বিভ্রান্তিকর হবে। সুতরাং যদি আমি এই জাতীয় কিছু লিখতে চাই তবে আমি নিশ্চিত করতাম যে vস্থির থাকে। আপনার উদাহরণের জন্য, আমি নিখরচায় ফাংশন যুক্ত করব

auto normalized(Vector v) -> Vector {return v.normalize();}
auto negated(Vector v) -> Vector {return v.negate();}

এবং তারপরে লুপগুলি লিখুন

for( double x : negated(normalized(v)) ) { ... }

এবং

for( double x : normalized(Vector{1., 2., 3}) ) { ... }

এটি আইএমও আরও ভাল পাঠযোগ্য এবং এটি আরও নিরাপদ। অবশ্যই এটির জন্য একটি অতিরিক্ত অনুলিপি প্রয়োজন, তবে হিপ-বরাদ্দ হওয়া ডেটার জন্য এটি সম্ভবত সস্তা সি ++ 11 সরানো অপারেশনে করা যেতে পারে।