के std::sort()रूप में घोषित एक सरणी को सॉर्ट
करने के लिए मानक टेम्पलेट लाइब्रेरी का उपयोग कैसे करें int v[2000];
क्या C ++ कुछ फ़ंक्शन प्रदान करता है जो किसी सरणी का आरंभ और अंत सूचकांक प्राप्त कर सकता है?
के std::sort()रूप में घोषित एक सरणी को सॉर्ट
करने के लिए मानक टेम्पलेट लाइब्रेरी का उपयोग कैसे करें int v[2000];
क्या C ++ कुछ फ़ंक्शन प्रदान करता है जो किसी सरणी का आरंभ और अंत सूचकांक प्राप्त कर सकता है?
जवाबों:
C ++ 0x / 11 में हम प्राप्त करते हैं std::beginऔर std::endजो सरणियों के लिए अतिभारित होते हैं:
#include <algorithm>
int main(){
int v[2000];
std::sort(std::begin(v), std::end(v));
}
यदि आपके पास C ++ 0x तक पहुंच नहीं है, तो उन्हें स्वयं लिखना मुश्किल नहीं है:
// for container with nested typedefs, non-const version
template<class Cont>
typename Cont::iterator begin(Cont& c){
return c.begin();
}
template<class Cont>
typename Cont::iterator end(Cont& c){
return c.end();
}
// const version
template<class Cont>
typename Cont::const_iterator begin(Cont const& c){
return c.begin();
}
template<class Cont>
typename Cont::const_iterator end(Cont const& c){
return c.end();
}
// overloads for C style arrays
template<class T, std::size_t N>
T* begin(T (&arr)[N]){
return &arr[0];
}
template<class T, std::size_t N>
T* end(T (&arr)[N]){
return arr + N;
}
std::begin()और std::end()वर्तमान C ++ मानक का हिस्सा नहीं हैं, लेकिन आप उपयोग कर सकते हैं boost::begin()और boost::end()।
beginऔर endफ़ंक्शन था। C ++ 11 से पहले, हालांकि, उन्हें एक सीरियस नुकसान था: वे एक अभिन्न निरंतर अभिव्यक्ति में परिणाम नहीं हुए। इसलिए विशिष्ट आवश्यकताओं के आधार पर, हम उनका उपयोग करेंगे, या एक मैक्रो जो दोनों का विभाजन किया था sizeof।
decltypeनिश्चित रूप से कुछ उपयोगों को सरल करता है, लेकिन मैं यह नहीं देखता कि इसे मुफ्त beginऔर endकार्यों के साथ क्या करना है । (और आपको वास्तव में उनमें से प्रत्येक दो होना चाहिए, सी शैली सरणियों के लिए एक, और कंटेनरों के लिए एक और, स्वचालित भेदभाव के साथ, इसलिए आप उन्हें टेम्पलेट में उपयोग कर सकते हैं, बिना यह जाने कि प्रकार एक कंटेनर है या सी शैली सरणी।)
#include <algorithm>
static const size_t v_size = 2000;
int v[v_size];
// Fill the array by values
std::sort(v,v+v_size);
में सी ++ 11 :
#include <algorithm>
#include <array>
std::array<int, 2000> v;
// Fill the array by values
std::sort(v.begin(),v.end());
std::vector। मेरा कोड होगा:std::vector<int> v(2000); std::sort( v.begin(), v.end() );
यदि आपको आकार की जानकारी नहीं है, तो आप उपयोग कर सकते हैं:
std::sort(v, v + sizeof v / sizeof v[0]);
यहां तक कि अगर आपको आकार पता है, तो इसे इस तरह से कोड करना एक अच्छा विचार है क्योंकि यह एक बग की संभावना को कम कर देगा यदि सरणी आकार बाद में बदल दिया जाता है।
sizeof x/sizeof *xट्रिक का उपयोग करने के बजाय आपको एक सुरक्षित टेम्पलेट का उपयोग करना चाहिए: template <typename T, int N> int array_size( T (&)[N] ) { return N; }जैसे कि यदि आप एक पॉइंटर पास करते हैं तो एक सरणी के बजाय यह विफल हो जाएगा। जरूरत पड़ने पर इसे एक संकलन समय में परिवर्तित किया जा सकता है, लेकिन यह एक टिप्पणी में पढ़ना थोड़ा कठिन हो जाता है।
begin()और end()फ़ंक्शन टेम्प्लेट है जो सभी सामान्य कंटेनर प्रकारों के लिए विशिष्ट हैं, जिसमें सरणियाँ शामिल हैं, और इसके बजाय उनका उपयोग करें। Xeo के जवाब से मुझे लगा कि ये पहले ही C ++ में जुड़ चुके हैं, अब ऐसा लगता है कि उन्होंने ऐसा नहीं किया है ... मैं देखूंगा कि लोगों को क्या कहना है और फिर अपडेट करना होगा।
begin, end, size, STATIC_SIZE(मैक्रो रिटर्न आकार के साथ एक संकलन समय निरंतर), लेकिन ईमानदारी से, मैं शायद ही कभी छोटे कोड नमूनों की है कि बाहर का उपयोग करें।
std::extent<decltype(v)>::valueC ++ 11
//It is working
#include<iostream>
using namespace std;
void main()
{
int a[5];
int temp=0;
cout<<"Enter Values"<<endl;
for(int i=0;i<5;i++)
{
cin>>a[i];
}
for(int i=0;i<5;i++)
{
for(int j=0;j<5;j++)
{
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
cout<<"Asending Series"<<endl;
for(int i=0;i<5;i++)
{
cout<<endl;
cout<<a[i]<<endl;
}
for(int i=0;i<5;i++)
{
for(int j=0;j<5;j++)
{
if(a[i]<a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
cout<<"Desnding Series"<<endl;
for(int i=0;i<5;i++)
{
cout<<endl;
cout<<a[i]<<endl;
}
}
यह उतना ही सरल है ... C ++ आपको STL (स्टैंडर्ड टेम्प्लेट लाइब्रेरी) में एक फ़ंक्शन प्रदान कर sortरहा है, जिसे हैंड-कोडेड क्विक-सॉर्ट की तुलना में 20% से 50% तेज गति से चलाया जाता है ।
यहाँ इसका उपयोग के लिए नमूना कोड है:
std::sort(arr, arr + size);
C ++ सॉर्टिंग फंक्शन का उपयोग करते हुए
#include <bits/stdc++.h>
using namespace std;
vector <int> v[100];
int main()
{
sort(v.begin(), v.end());
}
std::sort(arr, arr + arr_size)
C ++ std::sortफ़ंक्शन का उपयोग करें :
#include <algorithm>
using namespace std;
int main()
{
vector<int> v(2000);
sort(v.begin(), v.end());
}
//sort by number
bool sortByStartNumber(Player &p1, Player &p2) {
return p1.getStartNumber() < p2.getStartNumber();
}
//sort by string
bool sortByName(Player &p1, Player &p2) {
string s1 = p1.getFullName();
string s2 = p2.getFullName();
return s1.compare(s2) == -1;
}
बिना छँटाई विधि std::sort:
// sorting myArray ascending
int iTemp = 0;
for (int i = 0; i < ARRAYSIZE; i++)
{
for (int j = i + 1; j <= ARRAYSIZE; j++)
{
// for descending sort change '<' with '>'
if (myArray[j] < myArray[i])
{
iTemp = myArray[i];
myArray[i] = myArray[j];
myArray[j] = iTemp;
}
}
}
पूरा उदाहरण चलाएं :
#include <iostream> // std::cout, std::endl /* http://en.cppreference.com/w/cpp/header/iostream */
#include <cstdlib> // srand(), rand() /* http://en.cppreference.com/w/cpp/header/cstdlib */
#include <ctime> // time() /* http://en.cppreference.com/w/cpp/header/ctime */
int main()
{
const int ARRAYSIZE = 10;
int myArray[ARRAYSIZE];
// populate myArray with random numbers from 1 to 1000
srand(time(0));
for (int i = 0; i < ARRAYSIZE; i++)
{
myArray[i] = rand()% 1000 + 1;
}
// print unsorted myArray
std::cout << "unsorted myArray: " << std::endl;
for (int i = 0; i < ARRAYSIZE; i++)
{
std::cout << "[" << i << "] -> " << myArray[i] << std::endl;
}
std::cout << std::endl;
// sorting myArray ascending
int iTemp = 0;
for (int i = 0; i < ARRAYSIZE; i++)
{
for (int j = i + 1; j <= ARRAYSIZE; j++)
{
// for descending sort change '<' with '>'
if (myArray[j] < myArray[i])
{
iTemp = myArray[i];
myArray[i] = myArray[j];
myArray[j] = iTemp;
}
}
}
// print sorted myArray
std::cout << "sorted myArray: " << std::endl;
for (int i = 0; i < ARRAYSIZE; i++)
{
std::cout << "[" << i << "] -> " << myArray[i] << std::endl;
}
std::cout << std::endl;
return 0;
}
आप उपयोग कर सकते हैं,
std::sort(v.begin(),v.end());
beginऔर endतरीके हैं। आप एक के बारे में सोच होना चाहिए vector।
std::begin()औरstd::end()C ++ 1x जोड़? वे बहुत अच्छे हैं - शुरू से ही इस तरह से होना चाहिए था, यह बहुत सारे एल्गोरिदम को अधिक सामान्य बना देता था!