Ang mga sumusunod na operator ng arithmetic ay tinukoy sa C++.

Pagdaragdag;

– pagbabawas;

* pagpaparami

/ dibisyon

% modulo division

– – pagbaba (bawasan ng 1)

Pagtaas (pagtaas ng 1).

Ang aksyon ng mga operator +, –, * at / ay kasabay ng pagkilos ng mga katulad na operator sa algebra. Maaaring ilapat ang mga ito sa anumang built-in na numeric na uri ng data.

Pagkatapos ilapat ang division operator (/) sa isang integer, ang natitira ay itatapon. Halimbawa, ang resulta ng integer division 10/3 ay 3. Ang natitira sa dibisyon ay maaaring makuha gamit ang modulo operator (%). Halimbawa, ang 10%3 ay katumbas ng 1. Nangangahulugan ito na sa C++ ang % operator ay hindi magagamit sa mga non-integer na uri ng data.

Ang increment (++) at decrement (– –) operator ay may napakakagiliw-giliw na katangian. Samakatuwid, dapat silang bigyan ng espesyal na pansin.

Ang increment operator ay nagdaragdag ng numero 1 sa operand nito, at ang decrement operator ay nagbabawas ng 1 mula sa operand nito. Nangangahulugan ito na ang mga tagubilin:

katulad ng tagubiling ito:

At ang mga tagubilin:

katulad ng tagubiling ito:

Ang increment at decrement operator ay maaaring lumitaw alinman sa harap ng kanilang operand (prefix form) o pagkatapos nito (postfix form). Halimbawa, mga tagubilin

maaaring muling isulat bilang unlapi

X;//prefix form ng increment operator

o postfix form:

x++;//postfix form ng increment operator

Sa nakaraang halimbawa, hindi mahalaga kung ginamit ang increment operator sa anyong prefix o postfix. Ngunit kung ang increment o decrement operator ay ginagamit bilang bahagi ng isang mas malaking expression, kung gayon ang form kung saan ito ginagamit ay napakahalaga. Kung ang naturang operator ay ginagamit sa anyo ng prefix, pagkatapos ay gagawin muna ng C++ ang operasyong ito upang ang operand ay makakuha ng bagong halaga, na pagkatapos ay gagamitin ng natitirang bahagi ng expression. Kung ang operator ay ginagamit sa postfix form, ginagamit ng C++ ang lumang value nito sa expression at pagkatapos ay nagsasagawa ng operasyon na nagiging sanhi ng operand na kumuha ng bagong value.

Mga function ng matematika

Ang wikang C++ ay may mga espesyal na function para sa pagkalkula ng mga algebraic na expression. Ang lahat ng naturang function ay nakapaloob sa isang hiwalay na header file, math.h. Samakatuwid, upang magamit ang mga function sa code ng programa, dapat kang kumonekta ang file na ito gamit ang direktiba

#isama

Narito ang mga pangunahing algebraic function ng C++.

abs(x) - modulus ng isang integer;

labs(x) - module ng isang "mahabang" integer;

fabs(x) - modulus ng isang floating point number;

sqrt(x) - square root extraction;

pow(x,y) - pagtataas ng x sa kapangyarihan y;

cos(x) - cosine;

kasalanan(x) - sine;

tan(x) - padaplis;

acos(x) - arc cosine;

asin(x) - arcsine;

atan(x) - arctangent;

exp(x) - exponent sa x power;

log(x) - natural logarithm;

log10(x) - decimal logarithm

Kapag tinataas ang isang numero sa isang fractional na kapangyarihan, ang denominator ng fractional na kapangyarihan ay dapat na nakasulat sa tunay na anyo. Halimbawa: ang square root ng a ay nakasulat na ganito: pow(a,1/ 2.0 )

Ipakita natin ang paggamit ng mga function na may mga halimbawa.

5. I/O operator sa C++

Upang magpakita ng mensahe sa screen, gamitin ang sumusunod na pahayag ng C++:

cout<<”текст”;

#isama

Ang impormasyong nakapaloob sa dobleng panipi ay ang mensaheng dapat ipakita. Sa C++, ang anumang pagkakasunud-sunod ng mga character na nakapaloob sa double quote ay tinatawag na isang string dahil binubuo ito ng ilang mga character na pinagsama-sama upang bumuo ng isang mas malaking bloke (elemento).

Ang linya sa pahayag ng COUT ay maaaring maglaman ng tinatawag na mga wildcard na character - mga character na wala sa keyboard o ginagamit para sa mga pangunahing character sa teksto ng programa. Ang bawat wildcard na character ay pinangungunahan ng isang "\" character.

Narito ang isang listahan ng mga naturang simbolo:

\a – signal ng tunog

\n – pumunta sa bagong linya

\t – pahalang na tab

\v – patayong tab

\\ - backslash

\’ – nag-iisang quote

\” – dobleng panipi

\? – tandang pananong.

Halimbawa, isang operator tulad ng:

cout>>“halimbawa\nteksto”;

Ang salitang "halimbawa" ay lalabas sa isang linya, at ang salitang "teksto" sa kabilang linya.

Operator ng form:

cout>>“shop\””seagull\””;

Ang salitang "Seagull" ay ipapakita sa double quotes.

Bilang karagdagan sa teksto, maaaring ipakita ng operator ang mga halaga ng mga variable sa screen, pagsamahin ang mga ito sa teksto.

cout<<”a=”<

Naka-format na output

Upang ibalik ang mga halaga ng isang ibinigay na haba o katumpakan, ang cout operator ay may ilang mga setting:

cout.width(number) – kabuuang haba ng output value

cout.precision(number) – bilang ng mga decimal na lugar

cout.fill(‘filler symbol’) – isang simbolo na pumupuno sa mga karagdagang posisyon sa screen

Ang setting ng cout.width ay ni-reset sa paunang halaga nito pagkatapos magsagawa ng isang output statement. Samakatuwid, dapat itong tukuyin nang hiwalay para sa bawat variable o linya.

Ang mga setting para sa mga parameter na ito ay dapat gawin bago tumawag sa output operator.

Halimbawa:

//ilarawan ang mga variable

float a=125.478, b=625.365;

//itakda ang bilang ng mga character sa comma field

cout.precision(2);

//magtakda ng placeholder para sa mga karagdagang posisyon

cout.fill('0');

//magpakita ng mga variable na halaga sa screen

cout<<”a=”;

cout<<” b=”;

//itakda ang kabuuang haba para sa numero

Ang pagsasaayos ng lapad ng field (lapad) at tagapuno (punan) ay may katuturan kapag naglalabas ng data sa isang talahanayan. Kadalasan, makakalampas ka lang gamit ang precision setting.

Nililinis ang screen

Ang wikang C++ ay may function na nagbibigay-daan sa iyong i-clear ang screen ng impormasyon ng teksto. Ang function na ito ay mukhang:

Ang function na ito ay matatagpuan sa conio.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama

Pag-aayos ng isang pause upang tingnan ang resulta

Pagkatapos isagawa ang programa, kadalasan ay may awtomatikong pagbabalik sa window na may pinagmulang teksto. Hindi ito nagpapahintulot sa iyo na tingnan ang resulta na ipinapakita ng programa sa screen. Ang isang paraan sa labas ng sitwasyong ito ay maaaring gamitin ang Alt+F5 key, kapag pinindot, nakatago ang window na may program code. Kapag pinindot muli ang mga key na ito, ibabalik ang window ng code sa screen.

Gayunpaman, kung lumikha ka ng executable EXE file, imposibleng gamitin ang mga key na ito at ang resulta ay mananatiling hindi nakikita ng user.

Upang malutas ang problemang ito, maaari kang magdagdag ng isang function sa dulo ng program na humihinto hanggang sa pindutin ang anumang key. Ang function na ito ay mukhang:

getch();

Ang function na ito ay matatagpuan sa conio.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama

Operator sa pagpasok ng data ng keyboard

Upang mag-input ng data mula sa keyboard sa C++ mayroong isang operator:

cin >> variable;

Ang pahayag na ito ay naka-pause sa programa at naghihintay hanggang sa ipasok ng user ang halaga ng variable at pinindot ang ENTER.

Gamit ang isang operator, maaari mong ipasok ang mga halaga ng ilang mga variable. Upang gawin ito, ang operator ay nakasulat sa form:

cin>>variable1>>variable2>>. . .>>variablen;

Kapag sinimulan ang programa, ipasok ang bawat halaga na pinaghihiwalay ng isang puwang at pindutin ang ENTER sa dulo.

Ang pahayag ng COUT ay nasa iostream.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama (simula)

6. Halimbawa ng programa sa C++

Upang ipakita, lutasin natin ang isang problema. Sumulat ng isang programa upang mahanap ang halaga ng isang function:

Ang programa ay maaaring magmukhang:

//ikonekta ang file upang ayusin ang I/O

#isama

//isama ang file upang gumamit ng mga algebraic function

#isama

//isama ang file para tawagan ang screen clearing function

#isama

//pamagat ng pangunahing programa

//ilarawan ang tatlong variable ng totoong uri

// i-clear ang screen

//magpakita ng text hint sa screen

cout<<"Введите значения a и b:";

//humiling ng keyboard input ng dalawang variable: a at b

//kalkulahin ang halaga ng function

c=sin(a)+pow(cos(b),2);

//itakda ang katumpakan ng output ng resulta sa 3 decimal na lugar

cout.precision(3);

//ipakita ang resulta sa screen

cout<<"Функция равна:"<

cout<<"Для продолжения нажмите любую клавишу. . .";

//pause para tingnan ang resulta

//tapusin ang pangunahing programa

Ang lahat ng mga pag-andar ng matematika ay ipinatupad bilang mga pamamaraan ng klase ng Math, ang pangunahing nito ay ipinakita sa Talahanayan 4.1

Talahanayan 4.1 – Mga pangunahing larangan at pamamaraan ng klase sa Math

Pagpapatuloy ng Talahanayan 4.1

Isang halimbawa ng isang linear na programa sa pagkalkula gamit ang isang ibinigay na formula

namespace ConsoleApplicationl

( static void Main()

Console.WriteLine("Enter x");

buf=Console.ReadLine();

double x=Convert.ToDouble(buf);

Console.WriteLine("Enter alfa");

buf=Console.ReadLine();

double a=double.Parse(buf);

double y=Math.Sqrt(Math.PI*x)-

Math.Exp(0.2*Math.Sqrt(a))+

2*Math.Tan(2*a)+

1.6e3*Math.Log10(Math.Pow(x,2));

Console.WriteLine("Para sa x= (0) at alfa =(1)", x,a);

Console.WriteLine(“Resulta =” +y); )))

Lecture 5. C# language operators

Ang komposisyon ng mga operator ng wikang C#, ang kanilang syntax at semantika ay minana mula sa wikang C++. Ang anumang expression na nagtatapos sa isang semicolon ay isang pahayag.

Block o tambalang pahayag

Gamit ang mga kulot na brace, ang maraming mga pahayag sa wika (maaaring may interspersed na mga deklarasyon) ay maaaring pagsamahin sa isang solong syntactic construct na tinatawag na block o compound statement:

operator_1

operator_N

Sa syntactically, ang isang bloke ay itinuturing bilang isang pahayag at maaaring gamitin saanman sa mga konstruksyon kung saan ang syntax ay nangangailangan ng isang solong pahayag. Ang katawan ng loop at ang mga sanga ng if statement ay karaniwang kinakatawan bilang isang bloke.

Walang laman na operator

Ang walang laman na pahayag ay "walang laman" na winakasan ng isang semicolon. Ito ay ginagamit kapag ang syntax ay nangangailangan ng isang operator, ngunit ang kahulugan ay hindi. Minsan kapaki-pakinabang na ituring ang mga nawawalang pahayag bilang isang umiiral nang walang laman na pahayag. Syntactically katanggap-tanggap na magpasok ng mga dagdag na semicolon, kung ipagpalagay na ang mga walang laman na pahayag ay ipinapasok. Halimbawa, ang sumusunod na construction ay syntactically valid:

para sa (int j=1; j<5; j++) //оператор цикла

(;;;); //walang laman na operator

Maaari itong ituring bilang isang pagkaantala ng oras, idle operation.

Ang lahat ng mga function sa matematika ay nangangailangan ng isang header . Ang mga C program ay gumagamit ng isang header

Mangyaring suspindihin ang AdBlock sa site na ito.

Ang mga kalkulasyon sa matematika ay hindi limitado sa mga pagpapatakbong arithmetic lamang. Bilang karagdagan sa mga ito, maaari ka ring makahanap ng mga ugat, module, logarithms, trigonometric function, atbp. Alamin natin kung paano gamitin ang mga naturang function sa aming mga programa.

Upang gumamit ng mga mathematical function, kailangan mong isama ang header file math.h . Tinutukoy nito ang maraming iba't ibang mga pag-andar, ngunit sa ngayon ay titingnan natin ang mga sumusunod:

Ilang mathematical function

fabs(x) modulus ng numero x
sqrt(x) square root ng numero x
sin(x) sine ng x (x sa radians)
cos(x) cosine ng x (x sa radians)
pow(x, y) pagkalkula x y
exp(x) pagkalkula e x
log(x) natural logarithm ng x
log10(x) decimal logarithm ng x

Dalawang mahalagang punto.

• Ang lahat ng mga function ay nagbabalik ng dobleng halaga.
• Ang mga parameter ng function ay mga tunay na numero (doble), ngunit maaari ka ring magpasa ng mga integer. Mangyayari ito implicit na uri ng conversion. Ang compiler ay gagawa ng tunay na numero 3.0 mula sa isang integer, halimbawa 3.

Mga halimbawa.
Ang mga haba ng mga binti ng isang tamang tatsulok ay ibinibigay. Kalkulahin ang haba ng hypotenuse. Isang simpleng problema upang subukan ang iyong kaalaman sa Pythagorean theorem.

Listahan 1.

#isama #isama // ikonekta ang math.h int main (walang bisa) ( int a, b, c2; scanf("%d",&a); scanf("%d",&b); c2 = a*a + b*b; printf ("c = %.2f\n", sqrt(c2));

Kalkulahin ang sine ng anggulong ipinasok mula sa keyboard. Ang anggulo ay ipinasok sa mga degree.

Listahan 2.

#isama #isama // connect math.h int main (void) ( double alpha, sin_a, pi = 3.1415926; scanf("%lf",&alpha); alpha = alpha*pi/180; sin_a = sin(alpha); printf("% .2f\n", sin_a); return 0; )

Maraming dapat pag-usapan sa programang ito. Ang mga function na trigonometric na tinukoy sa math.h ay gumagana sa mga sukat ng radian na anggulo. Ang mga tao ay mas sanay na magtrabaho sa mga degree. Samakatuwid, sa program na ito una naming na-convert ang halaga mula sa mga degree sa radians. Kung hindi ito nagawa, magiging mali ang resulta. Suriin ito para sa iyong sarili.

Implicit na uri ng conversion

Kapag nagsasagawa ng isang tahasang uri ng conversion, isinaad namin sa panaklong bago ang halaga ang uri kung saan dapat i-cast ang halaga. Hindi na kailangang gawin ito sa isang implicit na conversion. Awtomatikong pipiliin ng compiler ang kinakailangang uri.

Implicit type conversion ay ginagawa sa mga sumusunod na kaso:

1. bago ipasa ang mga argumento sa function (tulad ng sa aming halimbawa ng ugat. Listahan 1.)
2. pagsasagawa ng mga operasyong aritmetika na may iba't ibang uri ng mga argumento
3. bago isagawa ang takdang-aralin

Mga panuntunan sa conversion na implicit na uri

• kung ang mga pagpapatakbo ng aritmetika ay isinasagawa gamit ang iba't ibang uri ng mga argumento. Ang parehong mga argumento ay inihagis sa mas malaking uri.
  Uri ng order: int< float < double
• kapag naatasan. Ang value sa kanan ng assignment operator ay inihagis sa uri ng variable sa kaliwa ng assignment operator. Gayunpaman, kung ang isang mas malaking uri ay itinalaga sa isang mas maliit, ang pagkawala ng katumpakan ay maaaring mangyari.

Ang int+float ay awtomatikong mako-convert sa float+float
float/int ay awtomatikong mako-convert sa float/float
ang double*float ay gagawing double*double
int = double double ay mako-convert sa int na may pagkawala ng fractional na bahagi
float = int int ay mako-convert sa float

Mga pag-andar ng matematika ng wikang C

Tinutukoy ng mga wikang C at C++ ang isang malawak na iba't ibang mga pag-andar sa matematika. Sa una, sinusuportahan ng parehong wika ang parehong hanay ng 22 mathematical function. Gayunpaman, habang nabuo ang wikang C++, lumawak ang arsenal ng mga function na tinukoy dito. Pagkatapos, sa bersyon C99, ang laki ng mathematical library ay tumaas nang malaki. Bilang resulta ng mga pagbabagong ito, ang mga aklatan ng mga pag-andar ng matematika ng mga wikang C at C++ ay nagsimulang magkaiba nang malaki sa bawat isa. Samakatuwid, inilalarawan ng kabanatang ito ang matematikal na pag-andar ng wikang C (kabilang ang mga idinagdag sa bersyon C99), at ang Kabanata 9 ay eksklusibong nakatuon sa mga paggana ng wikang C++. Gayunpaman, tandaan na ang orihinal na hanay ng mga function ng matematika ay sinusuportahan pa rin ng lahat ng bersyon ng C at C++.

Para magamit ang lahat ng mathematical function, dapat isama ng program ang header . Bilang karagdagan sa pagdedeklara ng mga mathematical function, tinutukoy ng header na ito ang isa o higit pang mga macro. Sa bersyon C89 ang header Ang HUGE_VAL macro lamang ang tinukoy, na isang dobleng halaga na nagpapahiwatig ng pag-apaw.

Ang mga sumusunod na macro ay tinukoy sa bersyon C99.

Tinutukoy ng bersyon ng C99 ang mga sumusunod na macro (tulad ng function) na nag-uuri ng isang halaga.

Sa bersyon C99, ang mga sumusunod na macro sa paghahambing ay tinukoy, ang mga argumento kung saan (a at b) ay dapat na mga floating point value.

Ang mga macro na ito ay pinangangasiwaan ang mga halaga na hindi mga numero nang maayos nang hindi nagtatapon ng mga tunay na uri ng pagbubukod.

Ang EDOM at ERANGE macros ay ginagamit din ng mga math function. Ang mga macro na ito ay tinukoy sa header .

Ang mga error sa mga bersyon C89 at C99 ay pinangangasiwaan nang iba. Kaya, sa C89, kung ang argumento ng math function ay hindi nasa loob ng domain kung saan ito tinukoy, ibinabalik ang ilang value na partikular sa pagpapatupad at ang built-in na global integer variable na errno ay nakatakda sa halaga ng EDOM. Sa C99, ang isang error sa paglabag sa domain ay nagreresulta din sa isang value na partikular sa pagpapatupad na ibinalik. Gayunpaman, ang halaga ng math_errhandling ay maaaring magpahiwatig kung ang ibang mga aksyon ay ginagawa. Kung ang math_errhandling ay naglalaman ng value na MATH_ERRNO, ang built-in na global integer variable na errno ay itatakda sa halaga ng EDOM. Kung ang math_errhandling ay naglalaman ng value na MATH_ERREXCEPT, isang tunay na exception ang ihahagis.

Sa C89, kung ang isang function ay bumubuo ng isang resulta na masyadong malaki para sa representasyon na pangasiwaan, isang overflow ang magaganap. Sa kasong ito, ang function ay nagbabalik ng HUGE_VAL at ang errno ay nakatakda sa ERANGE na halaga na nagpapahiwatig ng isang error sa saklaw. Kapag may nakitang underflow, ang function ay nagbabalik ng zero at itinatakda ang errno sa ERANGE. Sa C99, ang isang overflow na error ay nagiging sanhi din ng pag-andar na magbalik ng isang halaga. HUGE_VAL, at kung mawawalan ito ng kabuluhan - zero. Kung ang math_errhandling ay naglalaman ng value na MATH_ERRNO, ang global variable na errno ay itatakda sa value na ERANGE na nagsasaad ng error sa range. Kung ang math_errhandling ay naglalaman ng value na MATH_ERREXCEPT, isang tunay na exception ang ihahagis.

Sa bersyon C89, ang mga argumento sa mathematical function ay dapat na doble ang uri at ang mga halaga na ibinalik ng mga function ay may uri ng doble. Sa bersyon C99, idinagdag ang float at long double variant ng mga function na ito, na gumagamit ng mga suffix na f at l, ayon sa pagkakabanggit. Halimbawa, sa bersyon C89, ang sin() function ay tinukoy bilang mga sumusunod.

Dobleng kasalanan(double arg);

Sa bersyon C99, ang kahulugan sa itaas ng sin() function ay sinusuportahan at dalawa pang pagbabago ang idinagdag - sinf() at sinl().

Float sinf(float arg); mahabang double sinl(mahabang double arg);

Ang mga operasyon na ginagawa ng lahat ng tatlong mga function ay pareho; tanging ang data na sumailalim sa mga operasyong ito ang naiiba. Ang pagdaragdag ng f- at 1-modifications sa mga mathematical function ay nagbibigay-daan sa iyong gamitin ang bersyon na pinakaangkop sa iyong data.

Dahil nagdagdag ang C99 ng napakaraming bagong feature, sulit na ilista nang hiwalay ang mga feature na sinusuportahan ng C89 (ginagamit din ang mga ito sa C++).

At isa pang bagay: ang lahat ng mga anggulo ay tinukoy sa mga radian.

Tingnan din

acos - Ibinabalik ang halaga ng arc cosine
acosh - Ibinabalik ang halaga ng hyperbolic arc cosine
asin - Ibinabalik ang halaga ng arcsine
asinh - Ibinabalik ang hyperbolic arcsine value
atan - Ibinabalik ang halaga ng arctangent
atan2 - Ibinabalik ang arctangent ng a/b
atanh - Ibinabalik ang halaga ng hyperbolic arctangent
cbrt - Ibinabalik ang cube root value
ceil - Ibinabalik ang pinakamaliit na integer na mas malaki kaysa sa halaga ng ibinigay na argumento
copysign - Binibigyan ang ibinigay na argumento ng tanda na mayroon ang tinukoy na argumento
cos - Ibinabalik ang halaga ng cosine
cosh - Ibinabalik ang halaga ng hyperbolic cosine
erf - Ibinabalik ang halaga ng function ng error
erfc - Nagbabalik ng opsyonal na halaga ng function ng error
exp - Ibinabalik ang exponent value
exp2 - Ibinabalik ang numero 2 na itinaas sa ibinigay na kapangyarihan
expm1 - Ibinabalik ang halaga ng natural na logarithm e binawasan ng isa
fabs - Ibinabalik ang ganap na halaga
fdim - Nagbabalik ng zero o ang pagkakaiba ng dalawang ibinigay na argumento
floor - Ibinabalik ang pinakamalaking integer na mas mababa sa o katumbas ng halaga ng ibinigay na argumento
fma - Ibinabalik ang halaga ng a*b+c na ibinigay na mga argumento
fmax - Ibinabalik ang mas malaki sa dalawang value
fmin - Ibinabalik ang mas maliit sa dalawang value
fmod - Ibinabalik ang natitirang bahagi ng dibisyon
frexp - Hinahati ang isang ibinigay na numero sa mantissa at exponent nito
hypot - Ibinabalik ang haba ng hypotenuse na ibinigay sa haba ng dalawang binti
ilogb - Kinukuha ang exponential value
ldexp - Ibinabalik ang halaga ng expression na num*2^exp.