C++

[armen9494]

Կոմպիլյատորը թույլ ա տալիս որովհետև C++-ի կոմպիլյատորի համար a[0]-ն դա *(a+0)-ն է, a[1]-ը *(a+1)-ը, a[2]-ը *(a+2)-ը ..... a[i]-ն *(a+i)-ին: Իսկ քանի որ *(a+i) = *(i+a) հետևաբար
a[i] = i[a];

Ա դե պասկալըս ուրիշ էր էլի
Մերսի Լուսինային սենց հետաքրքիր հարց տալու ու Աշոտ ջան քեզ, սենց պարզ բացատրելու համար


Հ.Գ. եթե սենց հետաքրիր հարցեր էլի հիշեք, տվեք, փորձեմ մտածել, եթե նույնիսկ լուծումը չգտնեմ էլ, ապա էսքանից հետո հաստատ չեմ մոռանա

[Lusina]

Ա դե պասկալըս ուրիշ էր էլի
Մերսի Լուսինային սենց հետաքրքիր հարց տալու ու Աշոտ ջան քեզ, սենց պարզ բացատրելու համար


Հ.Գ. եթե սենց հետաքրիր հարցեր էլի հիշեք, տվեք, փորձեմ մտածել, եթե նույնիսկ լուծումը չգտնեմ էլ, ապա էսքանից հետո հաստատ չեմ մոռանա

Խնդրեմ, ինձ էլ ուրիշն ա ասել Ու քանի որ ինձ ասողը հետագայում շփոթության առիթ չլինելու համար ուրիշ բան էլ ա ասել, դա էլ ասեմ.
Սա սովորական int տիպի զանգվածի համար էր ճիշտ, սակայն std::vector -ի համար արդեն չենք կարող գրել v[i] == i[v].Սրա "ինչու"-ի մասին կարաս մտածես

[armen9494]

Խնդրեմ, ինձ էլ ուրիշն ա ասել Ու քանի որ ինձ ասողը հետագայում շփոթության առիթ չլինելու համար ուրիշ բան էլ ա ասել, դա էլ ասեմ.
Սա սովորական int տիպի զանգվածի համար էր ճիշտ, սակայն std::vector -ի համար արդեն չենք կարող գրել v[i] == i[v].Սրա "ինչու"-ի մասին կարաս մտածես

իսկ std::vector-ը ի՞նչ ա

[Lusina]

իսկ std::vector-ը ի՞նչ ա

c++-ի ստանդարտ գրադարանի թեմփլեյթ կլաս ա, ավելի մանրամասն այստեղ՝
http://www.cplusplus.com/reference/stl/vector/
Ի դեպ, հարցի պատասխանն էլ կա հղման մեջ, եթե ուշադիր լինես

[armen9494]

c++-ի ստանդարտ գրադարանի թեմփլեյթ կլաս ա, ավելի մանրամասն այստեղ՝
http://www.cplusplus.com/reference/stl/vector/
Ի դեպ, հարցի պատասխանն էլ կա հղման մեջ, եթե ուշադիր լինես

Անգլերենով էդքան էլ լավ չեմ հասկանում, նամանավանդ նման բաները. կփորձեմ ռուսերենը ման գալ: Շնորհակալություն

[Lusina]

Անգլերենով էդքան էլ լավ չեմ հասկանում, նամանավանդ նման բաները. կփորձեմ ռուսերենը ման գալ: Շնորհակալություն

Դե կարամ մի երկու բառով տնավարի նկարագրեմ Պատկերացրու քեզ ծանոթ մասիվը սովորական, որը կարա լինի քո ուզած տիպի.Այսինքն ինքը կոնտեյներ ա, որի էլեմենտները կլինեն քո ասած տիպով, մասնավորապես , կարան լինեն int տիպի.Ուղղակի vector-ը դա կլաս ա, ու երբ գրում ես v[i], կոմպիլյատոը "կանչում ա" իրա operator[] մեթոդը՝ v[i] == v.operator[](i);

[Ruzanna Stepanyan]

Դե x-ը կարող եք հայտարարել ինչ տիպի որ կուզեք, էդ կապ չունի:
Այ 100-ի փոխարեն n գրել ինչքան գիտեմ չենք կարող սովորական եղանակով (դե ալտերնատիվ միջոց հաստատ կլինի, բայց դժվար թե էդ ձեր խնդիրներում հետաքրքրի): Չնայած հնարավոր է նաև մի հեշտ հասկանալի մեթոդ առաջարկեն: Ինքս դեռ չգիտեմ:

Ախր խնդրում չի խոսում 100 թվի մասին, խնդիրը ասում է n տարր պարունակող զանգված

[ashot_1987]

Ախր խնդրում չի խոսում 100 թվի մասին, խնդիրը ասում է n տարր պարունակող զանգված

Զանգվածը հայտարարելիս ինդեքսում պետք է պարտադիր գրել հաստատուն թիվ օրինակ x[50], x[100], կամ const int p=60; int x[p], Զանգվածի ինդեքսում զանգվածը նկարագրելիս չեք կարող գրել փոփոխական թիվ: Դա նածատեսված է նրա համար քանի որ C++ կոմպիլյատորը կոմպիլյացիայից առաջ պետք է իմանա թե հիշողության մեջ ինչքան տեղ պետք է հատկացնի:
Տվյալ դեպքում այդպիսի խնդիրներում վարվում են այսպես` նախապես զանգվածը նկարագրում են այնքան տարրերով որքանը կբավարարի խնդրի լուծման, այսինքն եթե տվյալ խնդրի համար վերցնեք int x[1000], դժվար թե մեկի մտքով անցնի 1000-ից մեծ վերցնի n-ը:

C++ -ում իհարկե կա հնարավորություն որը թույլ կտա զանգվածի ինդեքսում վերցնել փոփոխական թիվ, բայց դրանք արվում են class-երով և կոչվում են դինամիկ հիշողություններ: Բայց այսքան պարզ խնդրի համար չեմ կարծում տենց բաներ պետք գան

[armen9494]

Զանգվածը հայտարարելիս ինդեքսում պետք է պարտադիր գրել հաստատուն թիվ օրինակ x[50], x[100], կամ const int p=60; int x[p], Զանգվածի ինդեքսում զանգվածը նկարագրելիս չեք կարող գրել փոփոխական թիվ: Դա նածատեսված է նրա համար քանի որ C++ կոմպիլյատորը կոմպիլյացիայից առաջ պետք է իմանա թե հիշողության մեջ ինչքան տեղ պետք է հատկացնի:
Տվյալ դեպքում այդպիսի խնդիրներում վարվում են այսպես` նախապես զանգվածը նկարագրում են այնքան տարրերով որքանը կբավարարի խնդրի լուծման, այսինքն եթե տվյալ խնդրի համար վերցնեք int x[1000], դժվար թե մեկի մտքով անցնի 1000-ից մեծ վերցնի n-ը:

C++ -ում իհարկե կա հնարավորություն որը թույլ կտա զանգվածի ինդեքսում վերցնել փոփոխական թիվ, բայց դրանք արվում են class-երով և կոչվում են դինամիկ հիշողություններ: Բայց այսքան պարզ խնդրի համար չեմ կարծում տենց բաներ պետք գան

Լրիվ համամիտ եմ Աշոտի հետ, մենք էլ սկզբում որ անցնում էինք էս խնդիրները, ասում էի ընդեղ ասվում ա n, ինչի՞ ենք նրա վրա սահմանափակում դնում, կամ եթե այդպես է՝ թող գրքում նշվի n-ի սահմանը:
Բայց դա նորմալ է ու այս խնդիրներում դինամիկ հիշողություն չենք օգտագործում, դա շատ ավելի բարդ է:

Թավով ընդգծաս պահը կանխարգելելու համար մենք n-ը ներմուծելիս էդ սահմանափակումը դնում ենք՝ "ներմուծել n-ը այնքան ժամանակ, քանի դեռ այն մեծ է 1000-ից և փոքր 1-ից" (այսինքն երբ n-ը կգտնվի 1-1000 միջակայքում, ծրագիրը կշարունակվի):

[ashot_1987]

Չգիտեմ ստեղ գրառմանը ոնց են Շնորհակալություն հայտնում, չգտա Մի խոսքով շնորհակալություն

[ashot_1987]

"ներմուծել n-ը այնքան ժամանակ, քանի դեռ այն մեծ է 1000-ից և փոքր 1-ից":

Բայց երևի հակառակը

[armen9494]

Չգիտեմ ստեղ գրառմանը ոնց են Շնորհակալություն հայտնում, չգտա Մի խոսքով շնորհակալություն

Հենց տակը կոճակ կա՝ "շնորհակալություն" Շատ շատ մերսի վարկանիշի համար

Բայց երևի հակառակը

Չէ, հենց այդպես. ներմուծել այնքան ժամանակ, քանի դեռ n-ը մեծ է 1000 կամ փոքր 1-ից:
Վայ, ընդեղ "և" եմ գրել

[ashot_1987]

Ներմուծել այնքան ժամանակ, քանի դեռ n-ը մեծ է 1000 կամ փոքր 1-ից:
Վայ, ընդեղ "և" եմ գրել

Ներմուծել այնքան ժամանակ, քանի դեռ n-ը մեծ է 1-ից փոքր է 1000-ից

[armen9494]

Ներմուծել այնքան ժամանակ, քանի դեռ n-ը մեծ է 1-ից փոքր է 1000-ից

Չէ, էդ դեպքում սխալ կլինի. նայի, ես օրինակ ներմուծում եմ 50, ինքը գնում ստուգում է՝ 50-ը մեծ է 1-ից և փոքր է 1000-ից ու նորից պահանջում ներմուծել n-ը: Իսկ եթե ես ներմուծեմ 2000, ինքը կգնա, կստուգի, որ 2000-ը մեծ է 1-ից, բայց փոքր չէ 1000-ից ու կշարունակի լուծել խնդիրը, արդյունքում սխալ ձևով (մեր դեպքում կուզի, որ ներմուծենք զանգվածի 2000 տարրերը):


Հ.Գ. ոնց որ թե Պասկալի հետ ես խառնում, ընդեղ էր պայմանը հակառակ ձևով դրվում, քանի որ "repeat" "until" էր, այսինքն արա գործողությունը, քանի դեռ պայմանը սխալ է:

[ashot_1987]

Չէ, էդ դեպքում սխալ կլինի. նայի, ես օրինակ ներմուծում եմ 50, ինքը գնում ստուգում է՝ 50-ը մեծ է 1-ից և փոքր է 1000-ից ու նորից պահանջում ներմուծել n-ը: Իսկ եթե ես ներմուծեմ 2000, ինքը կգնա, կստուգի, որ 2000-ը մեծ է 1-ից, բայց փոքր չէ 1000-ից ու կշարունակի լուծել խնդիրը, արդյունքում սխալ ձևով (մեր դեպքում կուզի, որ ներմուծենք զանգվածի 2000 տարրերը):


Հ.Գ. ոնց որ թե Պասկալի հետ ես խառնում, ընդեղ էր պայմանը հակառակ ձևով դրվում, քանի որ "repeat" "until" էր, այսինքն արա գործողությունը, քանի դեռ պայմանը սխալ է:

Չէ պասկալի հետ չեմ խառնում ուղղակի երևի ինչ որ բան կա իրար չենք հասկանում: Ստեղ n-ը զանգվածում տարրերի քանակն ա, որը ներմուծվում ա նախօրոք, ստուգվում ա մի անգամ, իսկ էտ ստուգվում ա սենց եթե ես զանգվածը նկարագրել եմ x[1000] ուրեմն իմ ներմուծած n-ը պետք ա լինի 1<n<1000, էս ոչ Պասկալ ա, ոչ C++, ոչ էլ Java, պարզ տրամաբանություն ա: