কাস্টম (যেমন ব্যবহারকারী সংজ্ঞায়িত) অবজেক্টযুক্ত ভেক্টরটিকে বাছাই করার ক্ষেত্রে কীভাবে যায়।
সম্ভবত, স্ট্যান্ডার্ড এসটিএল অ্যালগরিদম সাজানোর সাথে প্রডিকেট (একটি ফাংশন বা কোনও ফাংশন অবজেক্ট) যা কাস্টম অবজেক্টে ক্ষেত্রগুলির একটিতে (বাছাই করার জন্য কী হিসাবে) ব্যবহার করা উচিত।
আমি কি সঠিক পথে রয়েছি?
উত্তর:
ব্যবহার করে একটি সাধারণ উদাহরণ std::sort
struct MyStruct
{
int key;
std::string stringValue;
MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
};
struct less_than_key
{
inline bool operator() (const MyStruct& struct1, const MyStruct& struct2)
{
return (struct1.key < struct2.key);
}
};
std::vector < MyStruct > vec;
vec.push_back(MyStruct(4, "test"));
vec.push_back(MyStruct(3, "a"));
vec.push_back(MyStruct(2, "is"));
vec.push_back(MyStruct(1, "this"));
std::sort(vec.begin(), vec.end(), less_than_key());সম্পাদনা: হিসাবে কিরিল ভি Lyadvinsky নির্দিষ্ট, কেমন সম্পৃক্ত সরবরাহ পরিবর্তে, আপনি বাস্তবায়ন করতে পারেন operator<জন্য MyStruct:
struct MyStruct
{
int key;
std::string stringValue;
MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
bool operator < (const MyStruct& str) const
{
return (key < str.key);
}
};এই পদ্ধতিটি ব্যবহার করার অর্থ আপনি কেবলমাত্র ভেক্টরকে নিম্নরূপে বাছাই করতে পারবেন:
std::sort(vec.begin(), vec.end());সম্পাদনা 2: কাপ্পার পরামর্শ অনুসারে আপনি >অপারেটরকে ওভারলোড করে এবং সাজানোর কলকে কিছুটা পরিবর্তন করে ভেক্টরটিকে অবতরণ ক্রমে বাছাই করতে পারেন :
struct MyStruct
{
int key;
std::string stringValue;
MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
bool operator > (const MyStruct& str) const
{
return (key > str.key);
}
};এবং আপনার এইভাবে বাছাই করা উচিত:
std::sort(vec.begin(), vec.end(),greater<MyStruct>());std::sort(vec.begin(), vec.end(), greater<MyStruct>())পরিষ্কার এবং মার্জিত।
#include <functional>" স্টাড :: বৃহত্তর" ব্যবহার করা দরকার ।
operator<ব্যবহার করতে পারেন। std::sort(vec.begin(), vec.end());std::sort(vec.rbegin(), vec.rend());
কভারেজ স্বার্থে। আমি লাম্বদা এক্সপ্রেশন ব্যবহার করে একটি বাস্তবায়ন এগিয়ে রাখি ।
সি ++ 11
#include <vector>
#include <algorithm>
using namespace std;
vector< MyStruct > values;
sort( values.begin( ), values.end( ), [ ]( const MyStruct& lhs, const MyStruct& rhs )
{
return lhs.key < rhs.key;
});সি ++ 14
#include <vector>
#include <algorithm>
using namespace std;
vector< MyStruct > values;
sort( values.begin( ), values.end( ), [ ]( const auto& lhs, const auto& rhs )
{
return lhs.key < rhs.key;
});>পরিবর্তে ব্যবহার করুন <।
আপনি তৃতীয় যুক্তি হিসাবে ফান্টর ব্যবহার করতে পারেন std::sort, বা আপনি operator<আপনার শ্রেণিতে সংজ্ঞায়িত করতে পারেন ।
struct X {
int x;
bool operator<( const X& val ) const {
return x < val.x;
}
};
struct Xgreater
{
bool operator()( const X& lx, const X& rx ) const {
return lx.x < rx.x;
}
};
int main () {
std::vector<X> my_vec;
// use X::operator< by default
std::sort( my_vec.begin(), my_vec.end() );
// use functor
std::sort( my_vec.begin(), my_vec.end(), Xgreater() );
}constফাংশন স্বাক্ষরের শেষে আমাদের কেন যুক্ত করা দরকার ?
const।
constস্বাক্ষরের শেষে কীওয়ার্ডটি নির্দিষ্ট করে যে operator()ফাংশনটি Xgreaterস্ট্রাক্টের উদাহরণটি পরিবর্তন করে না (যা সাধারণভাবে সদস্য ভেরিয়েবল থাকতে পারে), তবে constইনপুট মানগুলির জন্য কেবল উল্লেখ করা হয় যে সেই ইনপুট মানগুলি অপরিবর্তনীয়।
এই জাতীয় vectorবা অন্য কোনও প্রযোজ্য (পরিবর্তনযোগ্য ইনপুট পুনরায় বিভাজনকারী) প্রকারের কাস্টম অবজেক্টের পরিসর বাছাই Xকরা বিভিন্ন পদ্ধতি ব্যবহার করে বিশেষত স্ট্যান্ডার্ড লাইব্রেরি অ্যালগরিদমের ব্যবহার সহ অর্জন করা যায়
sort, stable_sort, partial_sort অথবাpartial_sort_copy।যেহেতু বেশিরভাগ কৌশলগুলি, Xউপাদানগুলির আপেক্ষিক ক্রম অর্জনের জন্য ইতিমধ্যে পোস্ট করা হয়েছে, তাই আমি "কেন" এবং "কখন" বিভিন্ন পদ্ধতির ব্যবহারের জন্য কিছু নোট দিয়ে শুরু করব।
"সেরা" পদ্ধতির উপর নির্ভর করে বিভিন্ন কারণ:
Xবস্তুর সীমা বাছাই করা কি সাধারণ বা বিরল কাজ (এই ধরণের রেঞ্জগুলি প্রোগ্রামে বা লাইব্রেরি ব্যবহারকারীদের দ্বারা একাধিক পৃথক স্থানে বাছাই করা যাবে)?Xঅবজেক্টের রেঞ্জকে বাছাই করা বোকা হওয়া উচিত ?যদি রেঞ্জের সীমাবদ্ধকরণ Xএকটি সাধারণ কাজ এবং অর্জিত বাছাই করা প্রত্যাশিত হয় (যেমন Xকেবলমাত্র একটি একক মৌলিক মানটি আবৃত করে) তবে সম্ভবত অতিরিক্ত লোডিংয়ের জন্য যেতে হবেoperator< এটি কারণ এটি কোনও ঝাঁকুনি ছাড়াই বাছাই করতে সক্ষম করে (সঠিকভাবে সঠিক তুলনামূলক পাস করার মতো) এবং বারবার ফলন প্রত্যাশিত ফলাফল নেই।
যদি বাছাই একটি সাধারণ কাজ বা বিভিন্ন প্রসঙ্গে প্রয়োজন হতে পারে তবে একাধিক মানদণ্ড রয়েছে যা Xঅবজেক্টগুলিকে সাজানোর জন্য ব্যবহার করা যেতে পারে , আমি ফান্টেক্টর ( operator()কাস্টম ক্লাসগুলির ওভারলোডেড ফাংশন) বা ফাংশন পয়েন্টার (অর্থাত্ একটি ফান্টার / ফাংশন) যাব লেজিকাল অর্ডার করার জন্য এবং প্রাকৃতিক অর্ডারের জন্য অন্য একটি)।
Xঅন্যান্য প্রসঙ্গে যদি প্রকারের শ্রেণি বাছাই করা অস্বাভাবিক বা সম্ভাবনা না থাকে তবে আমি আরও ফাংশন বা প্রকারের সাথে কোনও নেমস্পেসের বিশৃঙ্খলা না করে ল্যাম্বডাস ব্যবহার করি।
এটি বিশেষত সত্য যদি বাছাই কোনওভাবে "পরিষ্কার" বা "প্রাকৃতিক" না হয়। আপনি operator<প্রথম দর্শনে ওপেন থাকাকালীন জায়গায় প্রয়োগ করা ল্যাম্বডায় তাকালে অর্ডারের পিছনে যুক্তিটি সহজেই পেতে পারেন এবং কী অর্ডারিং লজিক প্রয়োগ করা হবে তা জানতে আপনাকে সংজ্ঞাটি দেখতে হবে।
তবে খেয়াল করুন, একক operator<সংজ্ঞা ব্যর্থতার একক পয়েন্ট যেখানে একাধিক ল্যাম্বাস ব্যর্থতার একাধিক পয়েন্ট এবং আরও সতর্কতার প্রয়োজন।
সংজ্ঞা থাকলে operator<বাছাই সম্পন্ন যেখানে / সারণি টেমপ্লেট সংকলিত হয়েছে উপলব্ধ না হয় তবে কম্পাইলারটি বস্তুগুলির সাথে তুলনা করার সময় ক্রিয়াকলাপ করতে বাধ্য হতে পারে, ক্রমবর্ধমান ক্রম (কমপক্ষে যখন) লিঙ্ক টাইম অপ্টিমাইজেশন / কোড জেনারেশন প্রয়োগ করা হয়নি)।
class Xস্ট্যান্ডার্ড লাইব্রেরি বাছাইকরণ অ্যালগরিদম ব্যবহার করার জন্য তুলনামূলকতা অর্জনের উপায়যাক std::vector<X> vec_X;এবংstd::vector<Y> vec_Y;
T::operator<(T)বা operator<(T, T)এবং স্ট্যান্ডার্ড লাইব্রেরি টেম্পলেটগুলি ব্যবহার করুন যা তুলনা ফাংশনটি আশা করে না।হয় ওভারলোড সদস্য operator<:
struct X {
int i{};
bool operator<(X const &r) const { return i < r.i; }
};
// ...
std::sort(vec_X.begin(), vec_X.end());বা বিনামূল্যে operator<:
struct Y {
int j{};
};
bool operator<(Y const &l, Y const &r) { return l.j < r.j; }
// ...
std::sort(vec_Y.begin(), vec_Y.end());struct X {
int i{};
};
bool X_less(X const &l, X const &r) { return l.i < r.i; }
// ...
std::sort(vec_X.begin(), vec_X.end(), &X_less);bool operator()(T, T)একটি পছন্দসই ধরণের জন্য একটি ওভারলোড তৈরি করুন যা তুলনা ফান্টর হিসাবে পাস হতে পারে।struct X {
int i{};
int j{};
};
struct less_X_i
{
bool operator()(X const &l, X const &r) const { return l.i < r.i; }
};
struct less_X_j
{
bool operator()(X const &l, X const &r) const { return l.j < r.j; }
};
// sort by i
std::sort(vec_X.begin(), vec_X.end(), less_X_i{});
// or sort by j
std::sort(vec_X.begin(), vec_X.end(), less_X_j{});এই ফাংশন অবজেক্টের সংজ্ঞাগুলি সি ++ 11 এবং টেম্পলেটগুলি ব্যবহার করে কিছুটা জেনেরিক লেখা যেতে পারে:
struct less_i
{
template<class T, class U>
bool operator()(T&& l, U&& r) const { return std::forward<T>(l).i < std::forward<U>(r).i; }
};যা সদস্য iসমর্থন সহ যে কোনও ধরণের বাছাই করতে ব্যবহার করা যেতে পারে <।
struct X {
int i{}, j{};
};
std::sort(vec_X.begin(), vec_X.end(), [](X const &l, X const &r) { return l.i < r.i; });যেখানে সি ++ 14 আরও বেশি জেনেরিক ল্যাম্বডা এক্সপ্রেশন সক্ষম করে:
std::sort(a.begin(), a.end(), [](auto && l, auto && r) { return l.i < r.i; });যা ম্যাক্রোতে আবৃত হতে পারে
#define COMPARATOR(code) [](auto && l, auto && r) -> bool { return code ; }সাধারণ তুলনামূলক তৈরিটি বেশ মসৃণ করে তোলে:
// sort by i
std::sort(v.begin(), v.end(), COMPARATOR(l.i < r.i));
// sort by j
std::sort(v.begin(), v.end(), COMPARATOR(l.j < r.j));bool X_less(X const &l, X const &r) const { return l.i < r.i; }comparator কিন্তু constকীওয়ার্ড সরানো উচিত (যেমন একজন সদস্য ফাংশন নয়)।
std::sortবা অনুরূপ না করে যখন এর উদাহরণ প্রয়োজন Compare, যেমন একটি তাত্ক্ষণিক ক্ষেত্রে std::set?
template<class T, class C> std::set<T, C> make_set(C const& compare) { return std::set<T, C>{ compare }; }যা ব্যবহার করা যেতে পারে auto xset = make_set<X>([](auto && l, auto && r) { return l.i < r.i; });।
তুমি কি সঠিক পথে আছো. ডিফল্ট হিসাবে তুলনা ফাংশন হিসাবে std::sortব্যবহার করবে operator<। সুতরাং আপনার জিনিসগুলি বাছাই করার জন্য আপনাকে হয় অতিরিক্ত লোড করতে হবে bool operator<( const T&, const T& )বা একটি ফান্টর সরবরাহ করতে হবে যা তুলনা করে, অনেকটা এরকম:
struct C {
int i;
static bool before( const C& c1, const C& c2 ) { return c1.i < c2.i; }
};
bool operator<( const C& c1, const C& c2 ) { return c1.i > c2.i; }
std::vector<C> values;
std::sort( values.begin(), values.end() ); // uses operator<
std::sort( values.begin(), values.end(), C::before );ফ্যান্টেক্টর ব্যবহারের সুবিধা হ'ল আপনি ক্লাসের ব্যক্তিগত সদস্যদের অ্যাক্সেস সহ একটি ফাংশন ব্যবহার করতে পারেন।
operator< কারণ বিশ্বব্যাপী এক সংরক্ষিত ব্যবহার করতে পারে বা ব্যক্তিগত সদস্যদের, বর্গ (অথবা struct হয়) এর সদস্য। বা আপনার এটিকে স্ট্রাক্ট সি-এর বন্ধু করা উচিত
Std :: সাজানোর বিভিন্ন উপায়ের মধ্যে পারফরম্যান্সে যদি কোনও পরিমাপযোগ্য প্রভাব থাকে তবে আমি আগ্রহী ছিলাম, তাই আমি এই সাধারণ পরীক্ষাটি তৈরি করেছি:
$ cat sort.cpp
#include<algorithm>
#include<iostream>
#include<vector>
#include<chrono>
#define COMPILER_BARRIER() asm volatile("" ::: "memory");
typedef unsigned long int ulint;
using namespace std;
struct S {
int x;
int y;
};
#define BODY { return s1.x*s2.y < s2.x*s1.y; }
bool operator<( const S& s1, const S& s2 ) BODY
bool Sgreater_func( const S& s1, const S& s2 ) BODY
struct Sgreater {
bool operator()( const S& s1, const S& s2 ) const BODY
};
void sort_by_operator(vector<S> & v){
sort(v.begin(), v.end());
}
void sort_by_lambda(vector<S> & v){
sort(v.begin(), v.end(), []( const S& s1, const S& s2 ) BODY );
}
void sort_by_functor(vector<S> &v){
sort(v.begin(), v.end(), Sgreater());
}
void sort_by_function(vector<S> &v){
sort(v.begin(), v.end(), &Sgreater_func);
}
const int N = 10000000;
vector<S> random_vector;
ulint run(void foo(vector<S> &v)){
vector<S> tmp(random_vector);
foo(tmp);
ulint checksum = 0;
for(int i=0;i<tmp.size();++i){
checksum += i *tmp[i].x ^ tmp[i].y;
}
return checksum;
}
void measure(void foo(vector<S> & v)){
ulint check_sum = 0;
// warm up
const int WARMUP_ROUNDS = 3;
const int TEST_ROUNDS = 10;
for(int t=WARMUP_ROUNDS;t--;){
COMPILER_BARRIER();
check_sum += run(foo);
COMPILER_BARRIER();
}
for(int t=TEST_ROUNDS;t--;){
COMPILER_BARRIER();
auto start = std::chrono::high_resolution_clock::now();
COMPILER_BARRIER();
check_sum += run(foo);
COMPILER_BARRIER();
auto end = std::chrono::high_resolution_clock::now();
COMPILER_BARRIER();
auto duration_ns = std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count();
cout << "Took " << duration_ns << "s to complete round" << endl;
}
cout << "Checksum: " << check_sum << endl;
}
#define M(x) \
cout << "Measure " #x " on " << N << " items:" << endl;\
measure(x);
int main(){
random_vector.reserve(N);
for(int i=0;i<N;++i){
random_vector.push_back(S{rand(), rand()});
}
M(sort_by_operator);
M(sort_by_lambda);
M(sort_by_functor);
M(sort_by_function);
return 0;
}এটি যা করে তা হ'ল এলোমেলো ভেক্টর তৈরি করে এবং তারপরে অনুলিপি করতে এবং তার অনুলিপি বাছাই করতে কত সময় প্রয়োজন তা পরিমাপ করে (এবং খুব জোরালো ডেড কোড নির্মূলকরণ এড়াতে কিছু চেকসাম গণনা)।
আমি g ++ (GCC) 7.2.1 20170829 (রেড হ্যাট 7.2.1-1) দিয়ে সংকলন করছি
$ g++ -O2 -o sort sort.cpp && ./sortএখানে ফলাফল:
Measure sort_by_operator on 10000000 items:
Took 0.994285s to complete round
Took 0.990162s to complete round
Took 0.992103s to complete round
Took 0.989638s to complete round
Took 0.98105s to complete round
Took 0.991913s to complete round
Took 0.992176s to complete round
Took 0.981706s to complete round
Took 0.99021s to complete round
Took 0.988841s to complete round
Checksum: 18446656212269526361
Measure sort_by_lambda on 10000000 items:
Took 0.974274s to complete round
Took 0.97298s to complete round
Took 0.964506s to complete round
Took 0.96899s to complete round
Took 0.965773s to complete round
Took 0.96457s to complete round
Took 0.974286s to complete round
Took 0.975524s to complete round
Took 0.966238s to complete round
Took 0.964676s to complete round
Checksum: 18446656212269526361
Measure sort_by_functor on 10000000 items:
Took 0.964359s to complete round
Took 0.979619s to complete round
Took 0.974027s to complete round
Took 0.964671s to complete round
Took 0.964764s to complete round
Took 0.966491s to complete round
Took 0.964706s to complete round
Took 0.965115s to complete round
Took 0.964352s to complete round
Took 0.968954s to complete round
Checksum: 18446656212269526361
Measure sort_by_function on 10000000 items:
Took 1.29942s to complete round
Took 1.3029s to complete round
Took 1.29931s to complete round
Took 1.29946s to complete round
Took 1.29837s to complete round
Took 1.30132s to complete round
Took 1.3023s to complete round
Took 1.30997s to complete round
Took 1.30819s to complete round
Took 1.3003s to complete round
Checksum: 18446656212269526361দেখে মনে হচ্ছে ফাংশন পয়েন্টারটি ব্যতীত সমস্ত বিকল্প খুব সমান এবং কোনও ফাংশন পয়েন্টারটি পাস করার কারণে + 30% জরিমানার কারণ হয়।
দেখে মনে হচ্ছে অপারেটর <সংস্করণটি ~ 1% ধীর (আমি একাধিকবার পরীক্ষার পুনরাবৃত্তি করেছি এবং প্রভাবটি অব্যাহত রেখেছি), যা খানিকটা আশ্চর্যজনক কারণ এটি সূচিত করে যে উত্পন্ন কোডটি ভিন্ন (সেভ-- বিশ্লেষণ করার দক্ষতার অভাব রয়েছে) টেম্পস আউটপুট)।
হ্যাঁ, std::sort()তৃতীয় প্যারামিটারের সাথে (ফাংশন বা অবজেক্ট) আরও সহজ হবে। একটি উদাহরণ:
http://www.cplusplus.com/references/algorithm/sort/
আপনার ক্লাসে, আপনি "<" অপারেটরটি ওভারলোড করতে পারেন।
class MyClass
{
bool operator <(const MyClass& rhs)
{
return this->key < rhs.key;
}
}নীচে ল্যাম্বডাস ব্যবহার করে কোডটি দেওয়া হল
#include "stdafx.h"
#include <vector>
#include <algorithm>
using namespace std;
struct MyStruct
{
int key;
std::string stringValue;
MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
};
int main()
{
std::vector < MyStruct > vec;
vec.push_back(MyStruct(4, "test"));
vec.push_back(MyStruct(3, "a"));
vec.push_back(MyStruct(2, "is"));
vec.push_back(MyStruct(1, "this"));
std::sort(vec.begin(), vec.end(),
[] (const MyStruct& struct1, const MyStruct& struct2)
{
return (struct1.key < struct2.key);
}
);
return 0;
} // sort algorithm example
#include <iostream> // std::cout
#include <algorithm> // std::sort
#include <vector> // std::vector
using namespace std;
int main () {
char myints[] = {'F','C','E','G','A','H','B','D'};
vector<char> myvector (myints, myints+8); // 32 71 12 45 26 80 53 33
// using default comparison (operator <):
sort (myvector.begin(), myvector.end()); //(12 32 45 71)26 80 53 33
// print out content:
cout << "myvector contains:";
for (int i=0; i!=8; i++)
cout << ' ' <<myvector[i];
cout << '\n';
system("PAUSE");
return 0;
}আপনি ব্যবহারকারী সংজ্ঞায়িত তুলনামূলক ক্লাস ব্যবহার করতে পারেন।
class comparator
{
int x;
bool operator()( const comparator &m, const comparator &n )
{
return m.x<n.x;
}
}কোনও ভেক্টরকে বাছাই করতে আপনি বাছাই করতে পারেন () অ্যালগরিদম এ।
sort(vec.begin(),vec.end(),less<int>());ব্যবহৃত তৃতীয় পরামিতি আরও বেশি বা কম হতে পারে বা কোনও ফাংশন বা অবজেক্টও ব্যবহার করা যেতে পারে। তবে ডিফল্ট অপারেটরটি <আপনি যদি তৃতীয় প্যারামিটারটি খালি রাখেন।
// using function as comp
std::sort (myvector.begin()+4, myvector.end(), myfunction);
bool myfunction (int i,int j) { return (i<j); }
// using object as comp
std::sort (myvector.begin(), myvector.end(), myobject);typedef struct Freqamp{
double freq;
double amp;
}FREQAMP;
bool struct_cmp_by_freq(FREQAMP a, FREQAMP b)
{
return a.freq < b.freq;
}
main()
{
vector <FREQAMP> temp;
FREQAMP freqAMP;
freqAMP.freq = 330;
freqAMP.amp = 117.56;
temp.push_back(freqAMP);
freqAMP.freq = 450;
freqAMP.amp = 99.56;
temp.push_back(freqAMP);
freqAMP.freq = 110;
freqAMP.amp = 106.56;
temp.push_back(freqAMP);
sort(temp.begin(),temp.end(), struct_cmp_by_freq);
}যদি তুলনাটি মিথ্যা হয় তবে এটি "অদলবদল" করবে।