Айнымалылар мен өрнектер
Өрнек операндтар, операция белгілерінен, жақшалардан тұратын есептеуге арналған жиын. Операндтар өрнек, тұрақты немесе айнымалы болуы мүмкін.
Айнымалылар-анықталған тип деректері сақталатын жадының нақты бөлігінің аты. Айнымалының өз аты және мәні болады. Айнымалы аты оның мәні сақталған жады облысына қатынау үшін керек. Оның мәні програманың орындалу барысында өзгеріп отырады. Кез келген айнымалыны пайдаланбас бұрын сипаттап кету керек.
Бүтін және нақты айнымалыларды сипаттау мысалы:
int a; floft x;
Жалпы түрде айнымалыны сипаттау операторы төмендегідей болады:
[ жады класы] [ тұрақты ] тип аты [ инициализатор];
Осы операторды берудің негізгі ережелерін қарастырайық:
Міндетті емес жады класы auto, extern, static, register мәндерінің тек тек біреуін ғана қабылдайды.
Const модификаторы айнымалы мәні өзгертілмейтіндігін көрсетеді. Оларды тұрақтылар деп атайды.
Сипаттау барысында айнымалыға бастапқы мәнін беріп қойуға болады, оны иницализациялау деп атайды. Иницализациялауды екі формада беруге болады:
= мән
немесе
(мән)
тұрақты иницализацияланады сипаттау бөлімінде. Бір оператордың көмегімен бірдей типті бірнеше айнымалыны үтір арқылы ажыратып сипаттауға болады.
Мысалы:
short int a=1; // бүтін типті а
const char C = ‘C ‘; // символдық типті С
char s,sf=’ f ‘; // тек sf иницализацияланған
char t(54);
float c=0.22,x(3),sum;
Айнымалы типі мен иницализацияланатын мән типі сәйкес келмесе, онда типі өзгертіледі.Айнымалыны сипаттау барысында жады типі мен елассынан басқа айтпай-ақ оның әрекет ету облысы беріледі. Жады класы мен әрекет ету облысы тек сипаттаудың өзіне ғана байланысты емес, сонымен бірге программадағы орнына тікелей байланысты.
Идентификатордың әрекет ету облысы – онымен байланысқан жады облысына қатынау мүмкіндігі болатын программа бөлігі. Әрекет ету облысына байланысты олар локальды және ауқымды болып бөлінеді. Егер айнымалы блок ішінде анықталса сипатталуынан бастап, барлық блоктарда, ішкі құрылымды блоктарда да әсер етсе оны локальды деп атайды. Егер айнымалы блоктың сыртында сипатталса, әсер ететін аумағы сипатталуынан бастап соңына дейін болатын файл ауқымды деп аталады. Жады класы программалық объектінің көріну аймағы мен өмір сүруін анықтайды. Өмір сүруі тұрақты және уақытша болуы мүмкін. Жады класы үшін келесі спецификаторлар пайдаланылады:
auto-автоматты айнымалы. Оған жады стектен бөлінеді. Ол қатысатын оператор орындалған сайын қажеттілігіне қарай инциализацияланады. Сипатталғн блоктан шыққан кезде, жады босайды.
txtern- программаның басқа бөлігінде анықталады.
static-статистикалық айнымалы. Оның өмір сүруі тұрақты.
register- аuto сияқты, бірақ, процессордің регистры жады бөледі.
int a; //1 ауқымды айнымалы а
int main() {
int b; //2 ауқымды айнымалы b
extern int x; // 3 айнымалы х басқа жерде анықталған.
static int c; // 4 статистикалық айнымалы с
a=1; // 5 ауқымды айнымалыға меншіктеу
int a; //6 ауқымдыайнымалы а
a=2; // 7 ауқымды айнымалыға меншіктеу
::a=3; // 8 ауқымды айнымалыға меншіктеу
return 0;
}
int x=4; анықтау және инциализациялау х
мұндағы а айнымалы блоктардың сыртында сипатталған, сондықтан ол ауқымды. Оған жады сегменттен бөлінеді. Әрекет ету аумағы программаның барлық бөлігі. Ал b және c локольды айнымалы. Олардың өмір сүру уақыты әртүрлі. B үшін жады блокқа кіргенде стектен бөлінеді, ал блоктан шыққанда жады босатылады. C айнымалысы программа орындалу барысында сегментте орналасады, программа жұмысын аяқталғанша босатылмайды. Автоматты айнымалы инциализацияланбайды. Айнымалыны сипаттау хабарлау және анықтау арқылы жүргізіледі. Хабарлау- компилятор айнымалы типі туралы және класы туралы хабар береді, ал анықтау осыларға қоса, компиляторға типіне сәйкес жады бөлуді қамтамасыз етеді.
Операциялар
Келесі кестеде С++ тілінің негізгі операциялары көрсетілген. Операндтарының саныныа байланысты олар унарлы(бір операнд), бинарлы(екі операнд) және тернарлы(үш операнд) болып бөлінеді.
операциялар |
Қысқаша түсініктеме |
Унарлы операцялар |
|
++ |
1-ге арттыру |
-- |
1-ге кеміту |
sizeof |
өлшем |
~ |
разряд бойынша теріске шығару |
! |
логикалық теріске шығару |
- |
арифметикалық теріске шығару(унарлы минус) |
+ |
унарлы плюс |
& |
адресті алу |
* |
разадресация |
new |
жады бөлу |
delete |
жадыны босату |
(type) |
типті түрлендіру |
Бинарлы және тернарлы операциялар |
|
* |
көбейту |
/ |
бөлу |
% |
бөлудің қалдығы |
+ |
қосу |
- |
алу |
<< |
солға жылжу |
>> |
оңға жылжу |
< |
кем |
<= |
кем немесе тең |
> |
артық |
>= |
артық немесе тең |
= = |
тең |
!= |
тең емес |
& |
разряд бойынша конъюнкция(және) |
^ |
разряд бойынша немесені теріске шығару |
І |
разряд бойынша дизъюнкция (немесе) |
&& |
логикалық және (и) |
І І |
логикалық немесе (или) |
?: |
шартты операция |
= |
меншіктеу |
*= |
көбейтумен меншіктеу |
/= |
бөлумен меншіктеу |
%= |
бөлудің қалдығымен меншіктеу |
+= |
қосумен меншіктеу |
-= |
алумен меншіктеу |
<<= |
солға жылжумен меншіктеу |
>>= |
оңға жылжумен меншіктеу |
&= |
разряд бойынша И меншіктеумен |
І= |
разряд бойынша ИЛИ меншіктеумен |
^= |
Разряд бойынша исключающее или меншіктеумен |
, |
тізбектей есептеу |
Арттыру және кеміту операциялары(1-ге арттыру және 1-ге кеміту)
Бұл операциялардың екі түрлі формасында жазуға болады: префиксті және постфиксті. Префиксті формада операуия операндтың алдында жазылады. Операнд өзгереді, сосын оның мәні өрнектің нәтижелік мәні болады. Ал постфиксті формада өрнектің мәні операндтың бастапқы мәні болады, сосын өзгереді.
#include <stdio.h>
#include <conio.h>
int main () {
int x=3,y=3;
printf(“Значение префиксного выражения: %d\n”,++X);
printf(“Значение постфиксного выражения: %d\n”,y++);
printf(“Значение х после приращения: %d\n”, x);
printf(“Значение y после приращения: %d\n”, y);
getch();
return 0;
}
Программа нәтижесі келесідей:
Значение префиксного выражения: 4
Значение постфиксного выражения: 3
Значение х после приращения: 4
Значение y после приращения: 4
sizeof-өлшемді анықтау операциясы.
Типтің немесе объектінің өлшемін байтта береді, оның екі түрлі жазылу формасы бар:
sizeof өрнек
sizeof (тип)
Мысалы:
#include <iostream.h>
#include <conio.h>
int main(){
float x=1;
cout<<"sizeof(fioat) :"<<sizeof(float);
cout<<"\nsizeof x :" <<sizeof x;
cout<<"\nsizeof (x +1.0):" <<sizeof (x+1.0);
getch();
return 0;
}Программа орындалғаннан кейін келесі нәтиже болады:
sizeof(fioat) : 4
sizeof x : 4
sizeof (x+1.0) : 8
Соңғы нәтиже нақты тұрақты double типті болғандықтан ұзын орын бөлінеді.
Теріске шығару операциялары: (-,! және ~)
Арифметикалық теріске шығару(-) нақты және бүтін типті операндтардың таңбасын қарама-қарсыға ауыстырады.
Логикалық теріске шығару(!) егер операнд ақиқат болса, оның мәні 0, ал жалған болса, оның мәні 1-ге тең болады.
Разряд бойынше теріске шығару(~) екілік түрдегі бүтін санды операндты инвентирациялайды.
Бөлу(/) және бөлу қалдығы(%)
Бөлу операцясы тек арифметикалық типті операндтарға ғана қолданылады. Егер екі операндта бүтін типті болса, онда операция нәтижесі бүтін санға дейін дөңгелектенеді. Ал қалған жағдайда ережеге сәйкес түрлендіріледі. Бөлу қалдығы(%) операциясы тек бүтін типті операндтарға қолданылады.
#include <conio.h>
#include <stdio.h>
int main () {
int x=11, y=4;
float z=4;
printf("бөлу нәтижесі: %d %f\n", x/y,x/z);
printf("қалдық:%d\n", x%y);
getch();
return 0;
}
Программа орындалғаннан кейін келесі нәтиже болады:
Результаты деления: 2 2.75000
Остаток: 3
Жылжыту орперациясы(<<және >>) тек бүтін типті операндтарға қолданылады. Екілік түрдегі бірінші операнд оңға немесе солға екінші операндтың көрсетуімен жылжиды. Солға жылжығанда босаған разрядтарды нөлге айналдырамыз, ал егер бірінші операнд таңбасыз болса, онда оңға жылжығанда босаған биттерді нөлмен толтырамыз. Егер таңбалы болса, онда таңбаның разряды жазылыды.
Қатынас таңбалары(<,<=,>,>=, = =,!=) екі операндты салыстырады. Операндтар арифметикалық типті немесе көрсеткіштер болуы мүмкін. Нәтиже false және true мәндерін қабылдайды. Теңдікке және тең еместікке тексерудің басқаларға қарағанда басымдылығы төмен.
Разряд бойынша операциялар(&,І,^) тек бүтін санды операндтарға ғана қолданылады. Олардың екілік түрінде жұмыс істейді Операндтар биттік сәйкестікте салыстырады(бірінші операндтың бірінші биті мен екінші операндтың бірінші биті). Поразрядная конъюнкция(и) нәтижесі 1-ге тең егер, екі операндтың да сәйкес биттері 1-ге тең болса Поразрядная дизъюнкция (или) нәтижесі 1-ге тең егер, екі операндтың кем дегенде біреуінің сәйкес биттері 1-ге тең болса. Поразрядная исключающее или нәтижесі 1-ге тең егер, екі операндтың тек біреуінің сәйкес биттері 1-ге тең болса.
#include <iostream.h>
#include <conio.h>
int main(){
cout << "\n 6 & 5=" << (6 & 5);
cout << "\n 6 ² 5=" << (6 | 5);
cout << "\n 6 ^ 5=" << (6 ^ 5);
getch();
return 0 ;
}
Программа орындалғаннан кейін келесі нәтиже болады:
6 & 5=4
6 | 5=7
6 ^ 5=3
Логикалық операциялар(&&, ІІ) арифметикалық немесе көрсеткіштік типтерге қолданылады. Операндтар әрдбір операцияда әр түрлі болуы мүмкін. Нәтиже false және true мәндерін қабылдайды. Логикалық операция И(&&) нәтижесі true болады, егер тек екеуі де болса. Логикалық операция ИЛИ( ІІ) false мәнін қабылдайды, егер кем дегенде бір операнд false мәнін қабылдаса. Логикалық операциялар солдан оңға қарай орындалады. Нәтижені анықтауға бірінші операндтың мәні жеткілікті болса, онда екінші операндтың мәні есептелінбейді.
Меншіктеу операциялары(=,+=,-=,*=, т.б.)
Меншіктеу операциялары программаларда аяқталған операторлар сияқты қолданылады. Қарапайым меншіктеу форматы төмендегідей:
Операнд_1= Операнд_2
Сол жағындағы өрнектің мәні есептеліп, сол жағындағы жады ұяшығына жазылады. Онда тұрған бұрынғы мән жоғалады.
#include <iostream.h>
#include <conio.h>
int main(){
int a=3, b=5,c=7;
a=b,b=a; c=c+1;
cout << "a=" <<a;
cout << "\t b=" <<b;
cout << "\t c=" <<c;
getch();
return 0 ;
}Программа орындалғаннан кейін келесі нәтиже болады:
a=5 b=5 c=8
Меншіктеудің күрделі түрінде(+=,-=,*=,)
+= операциясы a=a+b жазуының орнына a+=b жазады. Сол жағындағы операндқа оң жағындағы операндты қосып жазады.
Шарттық опрация(?:) тернарлы операция, яғни үш операнд қатысады. Оның форматы:
Операнд_1? Операнд_2: Операнд_3
Бірінші операнд арифметикалық немесе көрсеткіш типті болуы мүмкін. Егер бірінші операндтың нәтижесі ақиқат болса, онда шартты операция ның нәтижесі екінші немесе үшінші операндтың нәтижесі болады.
#include <conio.h>
#include <stdio.h>
int main () {
int a=11, b=4, max;
max =(b >a)? b:a;
printf("ең үлкен сан; %d", max);
getch();
return 0 ;
}Программа нәтижесі
ең үлкен сан: 11
Шартты операцияның тағы бір мысалы:
i=(i < n) ? i+1:1;
Өрнек
Өрнек операндтардан, операция белгілерінен, жақшалардан тұрады. Әрбір операнд өрнек деп қарастырылады, әйтпесе жеке жағдайда тұрақты немесе айнымалы деп қарастырылады.
Мысалы:
(a+0.12)/6
x && y || !z
(t * sin(x)-1.05e4)/((2 * k +2) *(2 * k+3))
Операциялар басымдылығына қарай орындалалады. Олардың орындалу ретін өзгерту үшін дөңгелек жақшалар қолданылады. Бір өрнекте басымдылықтары бірдей бірнеше операция қолданылса, онда унарлы, шартты және меншіктеу операциялары оңнан солға қарай орындалады, қалғандары солдан оңға қарай. Мысалы: a=b=c жазуға эквивалентті a=(b=c), ал a+b+c жазуға эквивалентті (a+b)+c
3-дәріс. Структуралық программалаудың базалық конструкциялары. Қайталауды ұйымдастыру
Барлық есептерді шешу үшін құрылған програмалар үш структурадан тұрады: ілесу, тармақталу және цикл. Осы үш структураны структуралық программалаудың базалық конструкциялары деп атайды. Екі немесе одан көп операторлардың бірінен кейін бірінің тізбектеліп орындалуын ілесу деп айтады. Қандай да бір шарттың орындалуына байланысты тек екеуінің бірі ғана орындалатын оператор тармақталушы деп аталады. Циклдік деп қандай да бір оператор немесе операторлар тобының қайталанып орындалуы. Олардың ерекшелігі әрқайсысы тек бір кіру және тек бір шығу мүмкіндігі бар. Сондықтан да олар әртүрлі болып бір біріне кірісіп жатады.
«Өрнек» операторы нүктелі үтірмен аяқталатын кез келген өрнек оператор деп қарастырылады. Жеке жағдайда өрнек бос оператор деп қарастырылады.
i++; инкремент операциясы орындалады
a* = b+ c; көбейту қосумен орындалады,
fun(i, k); функцияны шақыру
Төменде жазылу реті бойынша тізбектеліп орындалатын ілесу конструкциясына мысал келтірілген.
a,b,c айнымалыларына нақты мәндері меншіктеледі.
# include <iostream.h>
# include <conio.h>
int main(){
int a=3, b=5,c=7;
a=b,b++; c=c+1;
cout << "a=" <<a;
cout << "\t b=" <<b;
cout << "\t c=" <<c;
getch();
return 0 ;
}
Тармақталушы конструкциялар.
Қандайда бір талаптардың қойылуына байланысты мүмкін жағдайды немесе қолайлы жағдайды таңдауға тура келеді. Ол шарт тексерумен жасалады. Шарттың орындалуына байланысты екі мүмкін варианттың біреуі ғана орындалады. Яғни, бір оператор орындалмай қалады.
Оның жазылу формасы төмендегідей
if (шарт) {оператор1;} else оператор 2;
Ең алғашқы арифметикалық немесе көрсеткіш типті өрнек орындалады. Егер ол нөлге тең болмаса(true мәнге тең болса), бірінші оператор орындалады, керісінше екінші оператор орындалады.Осыдан кейін шартты оперетардан кейінгісі орындалады.
Тармақтардың
біреуі қысқартылуы мүмкін, ол else сөзі
бар екінші тармақ. Егер тармақтардың
біреуінде бірнеше оператор орындалатын
болса, оларды блокқа алу керек, керісінше
компилятор тармақталу қай жерде
аяқталатынын білмейді. Блоктың ішіне
түрлі оператор кіруі мүмкін: сипаттау
және басқа шартты операторлар. Блокта
сипатталған айнымалы блоктан тыс
есептелінбейді. Оператор
Оператор 2
j
М
ысалы
үш a,b,c сандары берілсін. Осылардың ең
үлкенін табу керек .
Ол үшін алғашқы екеуін салыстырып, оның үлкенін (max) табамыз. Сол табылған үлкен санды (max) қалған үшінші санмен салыстыру арқылы сол екі санның үлкенін табамыз. Сол соңғы нәтиже болады.
# include <iostream.h>
# include <conio.h>
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int a,b,c,max;
cout << "vvedite a,b,c";
cin >>a >>b >>c;
if (a>b)max=a;else max=b;
if (c>max) max=c;
cout << max;
getch();
return 0;
}
Таңдау операторы Case
switch (бүтін Өрнек){
case тұр1: оператор1;break;
case тұр2: оператор2;break;
....
case тұрn: операторn;break;
Өрнек
2-оператор
1-оператор
default
: оператор;
default
оператор
Орындалу реті:
Біріншіден бүтін Өрнек мәні есептеледі.
Екіншіден сол нәтиже тұрақтылармен салыстырылады, қайсысына сәйкес келсе, соның тұсындағы оператор орындалады.
Егер тұрақтылардың ешқайсысына сәйкес келмесе оператор орындалады.
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
int main(){
int a,b,res;
char op;
cout<<"\n Vvedite 1operand:"; cin>> a;
cout<<"\n Vvedite znak operasi:"; cin>> op;
cout<<"\n Vvedite 2 operand:"; cin>> b;
bool f=true;
switch (op){
case '+': res=a+b;break;
case '-': res=a-b;break;
case '*': res=a*b;break;
case '/': res=a/b;break;
default : cout <<"\n Neisvesten op";f=false;
}
if (f)cout <<"\n resultat:"<< res;
getch();
return 0;
Цикл операторлары
Бірнеше рет қайталанып орындалатын есептеулерді ұйымдастыру үшін цикл қарастырылады. Олар қайталау денесі, бастапқы берілгендері, параметрдің модификациясы және шарттан тұрады. Циклдің бір рет орындалуы итерация деп аталады.Шарт барлық итерацида тексеріледі:біреуінде қайталау денесінің алдында, екіншісінде қайталау денесінен кейін. Шартта тексерілетін және қайталау денесіндегі өзгеріп отыратын айнымалы циклдің параметрі деп аталады.Әрбір итерацияда тұрақты қадаммен өзгеретін бүтін санды параметрлерциклдің есетеуітері де деп аталады.Қайталану шарты бұзылғанда цикл тоқтайды. Циклдің қайталануын күштеп тоқтатуға болады. Керісінше циклға сырттан кіруге болмайды.
a
1.8-сурет.Цикл операторларының құрылымдық сызбалары:
а- шарты алдында тексерілетін-цикл әзір;
б- шарты соңында тексерілетін цикл-дейін.
Шарты алдында тексерілетін-цикл әзір
While (өрнек) оператор;
Бастапқы берілгендері жазылып, өрнек мәні есептеледі. Өрнек қайталану денесінің шартты қызметін атқарады., егер оның нәтижесі ақиқат болса қайталау денесі орындалып жіне цикл параметрі жаңартылыды. Осылай қайталанып өрнектің мәні тексеріліп отырылады, жалған болғанда циклден шығамыз. Өрнектің типі арифметикалық немесе соған келтірілетін болуы керек. Алдын ала тексеру циклдегі нөлге бөлу және де басқа кемшіліктердің болуына жол бермейді. Егер циклда қайталанатын операторлар бірнешеу болса, онда операторлар блогын құру керек {}.
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
int main(){
int s=0,i=1;
while (i<=100)
{
s+=i;
i++;
}
cout<<"kosindi s="<<s;
getch();
return 0;
}
Программа нәтижесі
Шарты соңында тексерілетін цикл-дейін
Мұнда бастапқы берілгендерді жазғаннан кейін қайталанып орындалатын операторларды және цикл параметрі жаңартылады.Содан кейін ғана тексерілетін өрнек жазылады. Өрнек мәні ақиқат болса, қайталанатын операторлар орындалады, сосын ары қарай солай жалғасады.... Өрнек мәні жалған болғанға дейін қайталау жалғаса береді. Өрнек мәні жалған болғанда қайталаудан шығамыз.
Do оператор while (өрнек);
Енді осы мысалды do whlie операторы көмегімен есептесек, оның коды төмендегідей болады:
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
int main(){
int s=0,i=1;
do {
s+=i;
i++;
}
while (i<=100);
cout<<"kosindi s="<<s;
getch();
return 0;
}
Программа нәтижесі:
Осы екі циклдық операторлардың арасындағы айырмашылығы, do-while циклында оператор міндетті түрде бір рет орындалады.
for (инициализация; логӨрнек; модификациялар) оператор;
инициализациялауда циклдегі пайдаланылатын параметрдің типін көрсетіп, оған алғашқы мәні меншіктеледі.Оған үтір арқылы бірнеше оператор жазуға болады. Мысалы:
for (int i=0,j=2..
int r,m;
for (k=1,m=0;…
Өрнек нәтижесі логикалық типтен болатын өрнек. Өрнек мәні true болса, онда цикл қайталанып орындалады.
Модификациялар әрбір итерациядан кейін орындалатын оператор, цикл параметрін өзгертуге мүмкіндік береді.
int s=0;
for(int i=1;i<=100; i++) s+=i;
cout <<" \t pes=" << s ;
getch();
Одан кейін логикалық өрнек логӨрнек есептелінеді. Егер ол ақиқат- true, онда оператор орындалады, ЛогӨрнек false- жалған болса циклдың орындалуы тоқтатылады.
Үшінші түрі параметрлі цикл арқылы есептеп көрейік
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
int main(){
int s=0;
for(int i=1;i<=100;i++)
s+=i;
cout<<"kosindi s="<<s;
getch();
return 0;
}
Программа нәтижесі:
Ескертулер
қайталау денесіндегі меншіктеу операторларының оң жағындағы айнымалылардың осының алдындағы мәні меншіктелгендігін тексеру керек.
циклдан шығуға мүмкіндік беретін шартқа қатысатын айнымалы циклда өзгеретіндігін тексеру керек
циклдан шығудың басқа да жолдарын қарастыру керек.
қайталау денесі бір оператордан артық болса, оларды фигуралы жақшаға алу керек
do whlie операторын кем дегенде бір рет орындау керек жағдайда, ал whlie операторын алдын ала неше рет орындалатыны белгісіз және цикл параметрі көрінбейтін жағдайда қолданылады.
Басқаруды беру операторлары
goto- шарттыз көшу операторы
break- циклдан шығу
continue- келесі итерацияға көшу
return-функуиядан қайта оралу
goto- шарттыз көшу операторының форматы
goto белгі;
Осы сипаттау қатысқан функция денесінде міндетті түрде
белгі: оператор конструкциясы қатысуы керек. Белгі көрсеткен операторға басқару беріледі, яғни орындалу реті өзгеріп, келесі орындалатын оператор белгіден кейін тұрған оператор болады. Көп жағдайда
1. бірнеше циклдан текстің соңына оралу
2. функцияда бірнеше жерден бір операторға оралу керек жағдайда қолданылады
Басқаруды if,switch және циклдердің ішіне беруге болмайды.
Сонымен бірге төмендегідей жағдайда
int k; ...
goto metka;
{int s=3,b=4;
k=a+b;
metka: int m=k+1; ...
}
блоктың ішіне кіруге болмайды. Ондағы меншіктеу операторы орындалмайды.
break- циклдан шығу оператры Циклдың аяқталуын күтпей-ақ циклден шығуға немесе таңдау операторында таңдау жасауды аяқтау үшін қолданады.
# include <stdio.h>
# include <iostream.h>
# include <math.h>
# include <conio.h>
#pragma argsused
int main(int argc, char* argv[])
{
const int MaxIter=500;
double x,eps;
cout <<" \n VVedite argument i tochnost:";
cin >> x >> eps;
bool flag = true;
double y=x,ch=x;
for (int n=0; fabs(ch)>eps;n++){
ch*=x*x/((2*n+2)*(2*n+3));
y+=ch;
if (n>MaxIter) {cout<<"rad racxod";
flag=false;break;}
}
if (flag) cout<< "\n snachenie f:" <<y;
getch ();
return 0;
}
continue- келесі итерацияға көшу
return-функуиядан қайта оралу
Қолданушы анықтайтын деректер типі
Нақты есептерде өңделетін ақпарат күрделі структурадан тұруы мүмкін. Сондай жағдайда қолданушы өзі деректердің типін анықтап, онымен жұмыс жасайды.
Типтердің атын өзгерту(қайтадан ат беру)
typedef
Программаны түсінікті беру үшін, типке typedef қызметші сөі арқылы жаңа ат беруге болады. Ол үшін
typedef жаңа_ат[өлшем];
Мұндағы тік жақша синтаксистік элемент болады. Мысалы:
typedef unsigned int UNIT;
typedef char MGS[100];
typedef struct{
char fio [30];
int date,code;
double salary;}Worker;
Осылай енгізілген аттарды стандартты тип аттары сияқты
UNIT I,j { unsigned типінен}
MGS str[10] {10 жол 100 символдан тұратын массив}
Workerstaft[100] 100 структурадан тұратын массив}
Аттары ұзындау болып сипатталатын типтерді қолданушы қысқа атпен өзінше атын өзгертіп пайдалануына болады.
Атап беру(enum)
Программаларда нақты аты бар тұрақтылармен жұмыс істеуге тура келеді. Оларды сипаттау
enum[тип_аты] {тұрақтылар тізімі}
Тұрақтылар атап көрсетілген (тип_аты) типтен ғана мән қабылдай алады. Тұрақтылар бүтін типті және инциализациялануы кәдімгідей. Инциализацияланған жағдайда бірінші тұрақты нөлге айланады, ал қалғандарына бір саны автоматты түрде қосылып отырады. Атап беретін тип аты ерекше болуы керек. Олар # define директивасымен бірге іске қосылады.
4-дәріс. Бір өлшемді массивтер
Типтері бірдей элементтерге жалпылама ат беріп, ал әрқайсысын нөмері бойынша анықтауға болады. Оларды массивтер деп атайды. Массивтерді деректер сегментінде, стекте немесе жады бөлу операциясы көмегімен динамикалық жады облысында орналастыруға болады. Массивті сипаттау кезінде аты жазылғаннан кейін тік жақша ішіне оның элементтерінің саны орналасады. Мысалы, int a[10]; элементтерінің саны тұрақты сан, немесе тұрақты өрнек болуы керек.
Массивті инциализациялау
Сипаттау кезінде бастапқы мәндерін беріп кетуге болады.
int a[10]={1,1,2,2,2,100};
Бұл массивтің элементтерінің нөмері 0-ден 9-ға дейін өзгереді.
Массив өлшемі константа немесе тұрақты өлшеммен беріледі. Массив элементіне өту үшін оның атынан кейін квадрат жақшада элемент номері(индекс) көрсетіледі.
А буферлі айнымалысы арқылы I және min номерлі массив элементтерінің
Есеп:
10 элементтен тұратын бүтін санды массивте ең үлкен және ең кіші элементтерінің арасында неше оң элемент орналасқан екенін анықтау керек.
Ол үшін
максимальды және минимальды элементтердің алғашқы мәндерін беру керек. Алғашқы элементтерді алуға болады.
максимум және минимум мәндерді массивтің әрбір элементтерімен салыстыра отырыып, егер ағымдағы элемент осыған дейінгі максимум элементтен артық болса, онда осы элементті жаңа максимум деп аламыз. Керісінше, ағымдағы элемент бұрынғы минумумнан кем болса, онда осы элементті жаңа минумум деп аламыз.
Индестерін салыстыра отырып, есептеу басын анықтаймыз
максимум мән минумум мәннің алдында орналасса, онда бастапқы мән ретінде максимумнің индесісін, керісінше жағдайда минумум индексін алады.
4. оң элементтердің санын анықтайтын есептеуіш қоямыз, егер элемент нөлден артық болса, бір саны қосылып отырады.
//---------------------------------------------------------------------------
#include <conio.h>
#include <iostream.h>
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{const int n=10;
int a[n]={1,3,-5,1,-2,1,-1,3,8,4};
int i,imax,imin,count;
for (i=imax=imin=0; i<n;i++){
if (a[i]>a[imax]) imax=i;
if (a[i]<a[imin]) imin=i;
}
cout <<"\n\t max="<<a[imax]<<" min= "<<a[imin];
int ibeg=imax<imin ? imax :imin;
int iend=imax<imin ? imin :imax;
cout<<"\n\t ibeg="<<ibeg<<" iend= "<<iend;
for (count=0,i=ibeg+1;i<iend;i++)
if(a[i]>0)count++;
cout<<" Kolichestvo polozhitelnih: "<<count<<endl;
getch();
return 0;
}
//---------------------------------------------------------------------------
Программаны жұмысқа қосып, төмендегідей жауап аламыз:
Осы есепті басқаша алгоритммен есептеп көрейік.
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{const n=10;
int a[n];
int i,imax,imin,kol;
cout<<" Vvedite "<<n<<" tselih chisel:"<<endl;
for (i=0;i<n;i++) cin>>a[i];
for (i=0;i<n;i++) cout << a[i] << " ";
for (i=imax=imin=0;i<n;i++){
if (a[i]>a[imax]) imax=i;
if (a[i]<a[imin]) imin=i;
}
int d=0;
if (imax<imin) d=1;
else if (imax>imin) d=-1;
for (kol=0,i=imax+d;i!=imin;i+=d) if (a[i]>0) kol+=1;
cout<<"\n Kolichestvo polozhitelnih: "<<kol<<endl;
getch();
return 0;
}
//---------------------------------------------------------------------------
