प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. मानकपुस्तकालयःसूचीदयालु

सूचीयाः अधः स्तरः द्विपक्षीयः वृत्ताकारः लिङ्क्ड् सूचीसंरचना अस्ति यत्र सेन्टिनेल् बिट्स् सन्ति ।
forward_list इत्यस्य एकललिङ्क् कृते सूचीसंरचनायाः तुलने, list इत्यस्य पुनरावर्तकः द्विदिशा पुनरावर्तकः अस्ति
वेक्टर इत्यादिषु क्रमिकरूपेण संरचितपात्रेषु तुलने सूची कस्मिन् अपि स्थाने सम्मिलितुं विलोपयितुं च अधिकं कुशलं भवति, परन्तु कस्मिन् अपि स्थाने यादृच्छिकप्रवेशस्य समर्थनं न करोति
List इति टेम्पलेट् क्लास् अस्ति ।

सूचीवर्गस्य उपयोगं कुर्वन् भवद्भिः शीर्षकसञ्चिकां समाविष्टं कर्तव्यम्<list>

2. सूचीवर्गस्य सामान्यानि अन्तरफलकानि

1. सामान्यतया प्रयुक्ताः निर्मातारः

1. पूर्वनिर्धारितं कन्स्ट्रक्टर्, रिक्तं लिङ्क्ड् सूचीं निर्माति

list();

उदाहरणतया:

void test()
{
	list<int> lt;
}

2. एकं list object निर्माय n vals इत्यनेन आरम्भं कुर्वन्तु

list(size_type n, const value_type& val =  value_type());

उदाहरणतया:

void test()
{
	list<int> lt(3, 1);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

3.सूचीवर्गस्य रचनाकारं प्रतिलिख्यताम्

list(const list& x); 

उदाहरणतया:

void test()
{
	list<int> lt(3, 1);
	list<int> lt1(lt);
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

4. पुनरावर्तकस्य initialization constructor इत्यस्य उपयोगं कुर्वन्तु

Template<class InputIterator>
 
list(InputIterator first, InputIterator last);

उदाहरणतया:

void test()
{
	list<int> lt(3, 1);
	list<int> lt1(lt.begin(), lt.end());
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

2. सामान्यतया प्रयुक्ताः क्षमता-अन्तरफलकाः

अद्यापि तथैव अस्ति, अत्र मिलित्वा तस्य विषये वदामि ।

1.आकार, रिक्त, अधिकतम_आकार, आकार

आकृति:निर्वतनम्लिङ्क् कृता सूचीपात्रे तत्त्वानां संख्या ।

size_type size() const;

रिक्तम्‌:निर्वतनम्सूचीपात्रं शून्यं वा (अर्थात् तस्यआकृतिइति ०) ।
(टिप्पणी: एतत् कार्यं किमपि प्रकारेण पात्रं न परिवर्तयति। स्वच्छं कर्तुंलिङ्क् कृता सूचीपात्रस्य विषयवस्तु, द्रष्टव्यम्सूची::स्पष्टम्。）

bool empty() const;

अधिकतम_आकार(सामान्यतया न प्रयुक्तम्): returnलिङ्क् कृता सूचीपात्रे अधिकतमं तत्त्वानां संख्यां धारयितुं शक्नोति ।
(ज्ञातप्रणाल्याः पुस्तकालयस्य वा कार्यान्वयनसीमानां कारणात्, एषा अधिकतमक्षमता यत् पात्रं प्राप्तुं शक्नोतिआकृति , परन्तु पात्रं तत् आकारं प्राप्स्यति इति गारण्टी नास्ति: अद्यापि तत् आकारं प्राप्तुं पूर्वं कदापि भण्डारणं आवंटयितुं न शक्नोति । ) ९.

size_type max_size() const;

आकारं परिवर्तयन्तु:समाविष्टं कर्तुं पात्रस्य आकारं परिवर्तयन्तुनतत्त्वानि ।
यदिनवर्तमानपात्रात् लघुतरम्आकृति, सामग्री पूर्ववत् न्यूनीकरिष्यतेनतत्त्वान् अतिक्रान्तान् अपसारयन् (तान् नाशयन् च)।
यदिनवर्तमानपात्रात् बृहत्तरम्आकृति, ततः साधयितुं अन्ते आवश्यकसङ्ख्यायाः तत्त्वानां निवेशनेन सामग्री विस्तारिता भवतिन आकारस्य ।यदि निर्दिष्टम्वल, ततः नूतनं तत्त्वं आरभ्यतेवलप्रतिकृतयः, अन्यथा ते मूल्य-आरम्भिताः भवन्ति।
(ध्यायन्तु यत् एतत् कार्यं पात्रात् तत्त्वानि सम्मिलितं कृत्वा अथवा मेटयित्वा पात्रस्य वास्तविकसामग्री परिवर्तयति ।)

void resize (size_type n, value_type val = value_type());

उदाहरणतया:

​
void test()
{
	list<int> lt(3, 1);
	/*list<int> lt1(lt);*/
	list<int> lt1(lt.begin(), lt.end());
	list<int> lt2;
	cout << lt1.size() <<endl;
	cout << lt1.empty() <<endl;
	cout << lt2.empty() <<endl;
	lt1.resize(10);
	cout << lt1.size() << endl;
	for (auto i : lt1)
	{
		cout << i << " ";
	}
}
 
​

संचालन परिणामः : १.

3. सामान्यप्रवेशः, पारगमनं च

1.पुनरावृत्तिः

iterator begin();
 
const_iterator begin() const;
 
iterator end();
 
const_iterator end() const;

Iterator: लिङ्क्ड् सूचीयां प्रथमस्य नोड् इत्यस्य अन्तिमस्य नोड् इत्यस्य च स्थानं प्राप्तुं प्रयुक्तम्अग्रिमः स्थितिः (अर्थात् सेंटिनलस्थानम्) २.

उदाहरणतया:

void test()
{
	list<int> lt(5, 2);
	list<int> ::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
}

संचालन परिणामः : १.

2. विपर्यय पुनरावर्तकः

उल्टा_पुनरावृत्ति rbegin ();

const_reverse_iterator rbegin () const;

उल्टा_पुनरावृत्ति rend ();

const_reverse_iterator rend () स्थिरता;

Reverse iterator, rbegin इत्यनेन कंटेनर इत्यस्मिन् अन्तिमस्य नोड् इत्यस्य स्थानं प्राप्यते, rend इत्यनेन कंटेनर इत्यस्मिन् sentinel बिट् इत्यस्य स्थानं प्राप्नोति

void test()
{
	list<int> lt = { 1,23,4,4,5,2 };
	list<int> ::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		++rit;
	}
}

संचालन परिणामः : १.

नोटः- विपरीतपुनरावर्तक rit इत्यनेन अपि -- 100 इत्यस्य स्थाने ++ इत्यस्य उपयोगः करणीयः ।

3.अग्रे पृष्ठे च

पुरतः:

सन्दर्भ अग्रभाग ();

const_reference front () const;

लिङ्क्ड् सूचीयां प्रथमे नोड् मध्ये संगृहीतस्य दत्तांशस्य सन्दर्भं प्रत्यागच्छति

पृष्ठभागः:

सन्दर्भ पृष्ठ ();

const_reference back () const;

लिङ्क् कृतसूचौ अन्तिमे नोड् मध्ये संगृहीतस्य दत्तांशस्य सन्दर्भं प्रत्यागच्छति

उदाहरणतया:

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.front() << endl;
	cout << lt.back() << endl;
 
}

संचालन परिणामः : १.

4.सूचीं योजयन्तु, विलोपयन्तु, जाँचयन्तु, परिवर्तयन्तु च

१) push_front तथा ​​pop_front

push_front इति head insertion इति उच्यते, लिङ्क् कृतस्य सूचीयाः शिरःतः एकं तत्त्वं सम्मिलितं करोति

void push_front (const मूल्य_प्रकार & val);

pop_front इति head deletion इति कथ्यते, यत् लिङ्क् कृतस्य सूचीयाः शिरःतः एकं तत्त्वं विलोपयति ।

void pop_front ();

void pop_front();

उदाहरणतया:

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.front() << endl;
	lt.push_front(21345);
	cout << lt.front() << endl;
	lt.pop_front();
	cout << lt.front() << endl;
}

संचालन परिणामः : १.

२) पुश_बैक् तथा पॉप्_बैक्

push_back इति tail insertion इति उच्यते, लिङ्क्ड् सूचीयाः अन्ते एकं तत्त्वं सम्मिलितं करोति

void push_back (const मूल्य_प्रकार & val);

pop_back इति tail deletion इति उच्यते, यत् लिङ्क् कृतसूचिकायाः ​​अन्ते एकं तत्त्वं विलोपयति ।

void pop_back ();

उदाहरणतया:

void test()
{
	list<int> lt = {213123,123,34524,213};
	cout << lt.back() << endl;
	lt.push_back(21345);
	cout << lt.back() << endl;
	lt.pop_back();
	cout << lt.back() << endl;
}

संचालन परिणामः : १.

३) अन्वेष्टुम्

template <class InputIterator, class T>
 
InputIterator find(InputIterator first, InputIterator last, const T& val);

द्वयोः पुनरावर्तकयोः परिधिमध्ये val इति ज्ञात्वा पुनरावर्तकं यत्र स्थितं तत्र प्रत्यागच्छतु

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	*pos = 114514;
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

नोट्: इदं फंक्शन् सूचीयाः सदस्यकार्यं न भवति, अपितु मानकपुस्तकालयस्य कार्यम् अस्ति बहुविधाः पात्राः find फंक्शन् साझां कुर्वन्ति ।

यथा भवान् पश्यति, वयं प्रत्यक्षतया सूचीयाः पुनरावर्तकस्य सन्दर्भं त्यक्त्वा तस्याः सामग्रीं परिवर्तयितुं शक्नुमः, परन्तु पुनरावर्तकः नोड् प्रति सूचयितुं न अर्हति वा? किमर्थं तस्य सन्दर्भं त्यक्त्वा दत्तांशं परिवर्तयितुं शक्यते ?

वस्तुतः सूचीयाः पुनरावर्तकः मूलपारिस्थितिकीसूचकस्य उपयोगेन अनुकरणं न भवति कार्यान्वितः च भवति, तथा च अधः समाहितस्य आवश्यकता वर्तते, यत् सूचीयाः अनुकरणीयकार्यन्वयनस्य स्रोतसङ्केते प्रतिबिम्बितं भविष्यति

४)निवेशनम्

iterator insert (पुनरावर्तक स्थिति, const मूल्य_प्रकार & val);

void insert (पुनरावृत्ति स्थिति, आकार_प्रकार एन, const मूल्य_प्रकार & val);

————————————————————————————————————————

टेम्पलेट<class InputIterator>

void insert (पुनरावृत्ति स्थिति, InputIterator प्रथम, InputIterator अन्तिम);

स्थानस्य पुरतः एकं वा अधिकं वा तत्त्वं निवेशयन्तु

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	lt.insert(pos, 8848);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

सावधानाः छात्राः आविष्कृतवन्तः स्यात् यत् सूचीयाः insert operation अस्तिपुनरावर्तकस्य असिद्धत्वं न करिष्यति, यतः pos इत्यनेन सूचितः नोडः अपरिवर्तितः तिष्ठति, सापेक्षिकस्थानं च न परिवर्तते ।

परन्तु सूचीयाः विलोपनक्रियायाः कारणेन पुनरावर्तकस्य अमान्यता निश्चितरूपेण भविष्यति, तथा च केवलं विलोपनं नोडं प्रति सूचयति पुनरावर्तकः अमान्यः भविष्यति, अन्ये पुनरावर्तकाः अपि प्रभाविताः न भविष्यन्ति

५) मेटयतु

iterator erase(iterator position);
 
iterator erase(iterator first, iterator last);

स्थाने स्थितं तत्त्वं वा परिधिस्थं सर्वाणि तत्त्वानि अपास्यन्तु [प्रथमं, अन्तिमम्) ।

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 1);
	lt.erase(lt.begin());
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

void test()
{
	list<int> lt;
	for (int i = 0; i < 3; i++)
	{
		lt.push_back(i);
	}
	list<int>::iterator pos = find(lt.begin(), lt.end(), 2);
	lt.erase(lt.begin(),pos);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

६) स्वैप

शून्य स्वैप (सदिश & एक्स);

सूचीवस्तुद्वयं स्वैप् कुर्वन्तु

उदाहरणतया:

void test()
{
	list<int> lt;
	list<int> lt2(6, 12);
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.swap(lt2);
	for (auto i : lt2)
	{
		cout << i << " ";
	}
	cout << endl;
}

संचालन परिणामः : १.

७)नियुक्तिः

टेम्पलेट<class InputIterator>

void assign (InputIterator प्रथमं, InputIterator अन्तिम);

void असाइन (आकार_प्रकार एन, const मूल्य_प्रकार & val);

सूचीयाः कृते नूतना सामग्री निर्दिशन्तु, तस्य वर्तमानसामग्री प्रतिस्थापयन्तु, नोड्-सङ्ख्यां परिवर्तयन्तु च

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.assign(4, 0);
	for (auto i : lt)
	{
		cout << i << " ";
	}
}

संचालन परिणामः : १.

८)स्पष्टम्

void स्पष्ट ();

लिङ्क् कृतसूचिकायां सर्वाणि नोड्स् विलोपयन्तु

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	lt.clear();
	cout << lt.size() << endl;
}

संचालन परिणामः : १.

5.सूची क्रम परिवर्तन अन्तरफलक

(1）प्रकारं

void क्रमबद्धता ();

टेम्पलेट<class Compare>

void क्रमबद्धता (Compare comp);

सूचीसंरचनायाः विशेषतायाः कारणात् मानकपुस्तकालये क्रमणकार्यस्य उपयोगः कर्तुं न शक्यते, यतः पुनरावर्तकः घटावक्रियाः कर्तुं न शक्नोति ।

तथा च C++ दस्तावेजीकरणे वयं द्रष्टुं शक्नुमः यत् मानकपुस्तकालये क्रमणं पुनरावर्तकस्य प्रकारं यादृच्छिकप्रवेशः (RandomAccess) इति अपि सीमितं करोति ।

default (1)	
template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);
custom (2)	
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

पुनरावर्तकानां अनेकाः कार्यात्मकाः वर्गाः सन्ति : १.

• एकदिशा पुनरावर्तकः, केवलं ++ कर्तुं शक्नोति
• द्विदिशा पुनरावर्तकः, ++ तथा -- भवितुम् अर्हति ।
• यादृच्छिक पुनरावर्तकः, ++, --, + तथा - भवितुम् अर्हति ।

परन्तु सूचीयाः क्रमणकार्यं आवश्यकं नास्ति, यतः प्रत्यक्षतया लिङ्क् कृतसूचिकायाः ​​क्रमणस्य कार्यक्षमता सदिशं प्रति प्रतिलिपिं कृत्वा, क्रमणं कृत्वा ततः पुनः लिङ्क् कृतसूचौ प्रतिलिपिकरणात् बहु मन्दतरं भवति

(2）विपरीत

template <class BidirectionalIterator>
  void reverse (BidirectionalIterator first, BidirectionalIterator last);

लिङ्क् कृतं सूचीं विपर्यययन्तु

उदाहरणतया:

void test()
{
	list<int> lt;
	for (int i = 0; i < 10; i++)
	{
		lt.push_back(i);
	}
	for (auto i : lt)
	{
		cout << i << " ";
	}
	cout << endl;
	lt.reverse();
	for (auto i : lt)
	{
		cout << i << " ";
	}
	cout << endl;
 
}

संचालन परिणामः : १.

---

यदि दोषाः सन्ति तर्हि मां सम्यक् कुर्वन्तु।