Article

EDP

C & DS

Engg.Chemistry

Engg.Physics



అవునంటే కాదనిలే.... కాదంటే అవుననిలే
*యూనరీ ఆపరేటర్లు
నం ఇప్పటి వరకు నేర్చుకున్నవన్నీ బైనరీ, టెర్నరీ ఆపరేటర్లు. ఈ పాఠంలో ‘సీ’ లాంగ్వేజీలో ఉన్న యూనరీ ఆపరేటర్ల గురించి నేర్చుకుందాం. యూనరీ ఆపరేటర్లకు ఒక్క ఆపరాండ్ మాత్రమే వుంటుంది.

ఉదాహరణకు, c=a+b అనే దానిలో + కు రెండు ఆపరాండ్లు ఉన్నాయి, కాబట్టి దానిని బైనరీ + అని అంటారు. అదే, c= +b అనే దానిలో + ను యూనరీ + అని అంటారు. ఎందుకంటే దానికి ఒక్క ఆపరాండ్ మాత్రమే వుంది. అలాగే, c=-b అనే దానిలో – ను యూనరీ – అని అంటారు.

‘సీ’ లాంగ్వేజీలో negation, unary increment, decrement అనే మరికొన్ని యూనరీ ఆపరేటర్లు ఉన్నాయి. వాటి గురించి ఇప్పుడు తెలుసుకుందాం.

Negation Operator(!)

దీనిని మనం ఓ వేరియబుల్ కు అయినా, constant కు అయినా, expressionకు అయినా అప్లై చేయవచ్చు. అంటే దీని ఆపరాండ్ వేరియబుల్ అయినా, constant అయినా, expressionకు అయినా కావచ్చు. ఆపరాండ్ ట్రూ అయితే, దీనిని అప్లై చేసిన తర్వాత ఫాల్స్ అవుతుంది. అదే ఆపరాండ్ ఫాల్స్ అయితే, దీనిని అప్లై ఛెసిన తర్వాత రిజల్ట్ ట్రూ అవుతుంది. అంటే అవునంటే కాదనిలే, కాదంటే అవుననిలే అన్నమాట.

‘సీ’ లాంగ్వేజీలో positive అయినా, negative అయినా ట్రూ లాగా తీసుకొంటుంది. సున్నా అయితే ఫాల్స్ లాగా తీసుకుంటుంది. అలాగే, మనం ఇంతకు ముందు పాఠాల్లో ట్రూ అంటే 1 అని, ఫాల్స్ అయితే 0 అనీ తెలుసుకున్నాం. ఈ కింది ప్రోగ్రాంలో ఈ విషయాలను ఉపయోగించుకుందాం.

ఉదాహరణ
ఈ కింది ప్రోగ్రాం negation ఆపరేటరు వాడితే ఏమవుతుందో తెలియజేస్తుంది... చూడండి.
#include<stdio.h>
int main()
{
     int a=10, b=10, c=0, i,j,k,l,m,n,p,q,r;

     i=!a;
     j=!b;
     k=!c;
     l=!100;
     m=!-100;
     n=!0;
     p=!(a==10);
     q=!(a!=b);
     r=(!a ==10);
     printf("%d %d %d %d %d %d %d %d %d\n", i,j,k,l,m,n,p,q,r);
  return (0);
}
పై ప్రోగ్రాంలో ప్రతీ లైనులో ఏమి అవుతుందో తెలుసుకుందాం.

     
     

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ
ఇంతకు ముందు పాఠాల్లో అయిదుగురిలో ఎంతమంది పాస్ అయ్యారో కనుక్కోవడానికి ప్రోగ్రాం రాశాం. ఇక్కడ, negation వాడి ఎంత మంది ఫెయిల్ అయ్యారో తెలుసుకుందాం.

#include<stdio.h>

int main()
{
     int a,b,c,d,e,np;

     printf("Enter five students marks in a test\n");
     scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
     np=!(a>=35) + !(b>=35) + !(c>=35) + !(d>=35) + !(e>=35);

     printf("Number of students failed=%d\n", np);

  return (0);
}
పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ
ఈ కింది ప్రోగ్రాంలో, negation ఆపరేటరు లాజికల్ OR ఆపరేటరులు ఉన్న ఒక expression కు అప్లై చేస్తే ఏమవుతుందో చూపించాం. శాంపిల్ ఇంపుట్, అవుట్ పుట్ లను గమనించండి.

#include<stdio.h>

int main()
{
     int a,b,c,d,e,np;

     printf("Enter five students marks in a test\n");
     scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
     ( ((a>=35) || (b>=35) || (c>=35) || (d>=35) || (e>=35)) ) ? printf("Yes\n"):printf("No\n");
     ( !((a>=35) || (b>=35) || (c>=35) || (d>=35) || (e>=35)) ) ? printf("Yes\n"):printf("No\n");
  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ
ఈ కింది ప్రోగ్రాంలో, negation ఆపరేటరు లాజికల్ AND ఆపరేటర్లు ఉన్న ఒక expression కు అప్లై చేస్తే ఏమవుతుందో చూపించాం. శాంపిల్ ఇంపుట్, అవుట్ పుట్ లను గమనించండి.

 

#include<stdio.h>

int main()
{
     int a,b,c,d,e,np;

     printf("Enter five students marks in a test\n");
     scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
   ( ((a>=35) && (b>=35) && (c>=35) && (d>=35) && (e>=35)) ) ? printf("Yes\n"):printf("No\n");
   ( !((a>=35) && (b>=35) && (c>=35) && (d>=35) && (e>=35)) ) ? printf("Yes\n"):printf("No\n");
  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా వుంటుంది.

     

Unary Increment/Decrement Operators

వీటిని integer టైపు వేరియబుల్ కు మాత్రమే వాడవచ్చు. ఇక్కడ కూడా రెండు టైపులు ఉన్నాయి. అవి, postfix increment/decrement, prefix increment/decrement ఆపరేటర్లు. ఉదాహరణకు, ఈ కింది టేబుల్ లో A అనే వేరియబుల్ మీద వీటిని ఎలా వాడవచ్చో చూడండి.

     

వీటిని ఓ expression లో వాడితే ఏమవుతుందో ఈ కింది ప్రోగ్రాంల ద్వారా తెలుసుకుందాం.

ఉదాహరణ
ఈ ప్రోగ్రాం postfix, prefix increment ఆపరేటర్ల గురించి తెలియజేస్తుంది. ఇక్కడ, b=a++; లో ముందుగా a వాల్యూను b కు ఇచ్చి ఆ తర్వాత a వాల్యూ ఒకటి పెరుగుతు0ది. అలాగే, c=++a; లో ముందుగా a వాల్యూ ఒకటి పెరిగి ఆ పెరిగిన వాల్యూను c కు ఇస్తు0ది. ఇలాగా postfix, prefix increment ఆపరేటర్లు పని చేస్తాయి.

#include<stdio.h>

int main()
{
     int a=10,b,c;

     b=a++;
     printf("%d %d\n",a,b);
     c=++a;
     printf("%d %d\n", a, c);

  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ
ఈ ప్రోగ్రాం postfix, prefix decrement ఆపరేటర్ల గురించి తెలియజేస్తుంది. ముందుగా a వాల్యూను b కు ఇచ్చి ఆ తర్వాత a వాల్యూ ఒకటి తగ్గుతుంది. అలాగే, c=--a; లో ముందుగా a వాల్యూ ఒకటి తగ్గి ఆ తగ్గిన వాల్యూను c కు ఇస్తుంది. ఇలాగా postfix, prefix decrement ఆపరేటర్లు పని చేస్తాయి.

#include<stdio.h>

int main()
{
     int a=10,b,c;

     b=a--;
     printf("%d %d\n",a,b);
     c=--a;
     printf("%d %d\n", a, c);

     scanf("%d",&a);
  return (0);
}
పై ప్రోగ్రాం రిజల్ట్ ఈ విధం ఉటుంది.

     

ఒక expression లో ఒక వేరియబుల్ కు n postfix ఆపరేటర్లు ఉంటే, ఆ వేరియబుల్ ప్రస్తుత వాల్యూతో ఆ expression ను ఎవాల్యూయేట్ చేసి ఆ తర్వాత ఆ వేరియబుల్ వాల్యూ n సార్లు మారుతుంది. అలాగే, ఒక expression లో ఒక వేరియబుల్ కు n prefix ఆపరేటర్లు ఉంటే, ఆ వేరియబుల్ వాల్యూ n సార్లు ముందుగా మారుతుంది, ఆ మారిన వాల్యూతో expression ఎవాల్యుయేట్ అవుతుంది.

ఉదాహరణ
పైన వివరించిన అంశాలను ఈ కింది ప్రోగ్రాం ద్వారా తెలుసుకుందాం.
ఇక్కడ, b=a++ + a++ + a++;
లో a కు మూడు postfix increment లు వాడాం. కాబట్టి, ప్రస్తుత a వాల్యూ 10 తో a+a+a, అంటే 30 ను bకు ఇచ్చి ఆ తర్వాత a వాల్యూ మూడు సార్లు పెరుగుతుంది. అంటే 13 అవుతుంది. అలాగే, c=++a + ++a + ++a;
లో a కు మూడు prefix increment లు ఉన్నాయి. కాబట్టి a మూడు సార్లు పెరుగుతుంది. అంటే, 16 అవుతుంది. అప్పుడు, a+a+a, అంటే 16+16+16=48 కాలిక్యులేట్ చేసి c కు ఇస్తుంది. అలాగే, c=++a + ++a + ++a;
లో a కు ఒక prefix increment, postfix incrementలు ఉన్నాయి. కాబట్టి, a ముందు పెరుగుతుంది. అంటే, 17 అవుతుంది. దానితో a+a అంటే, 34 కాలిక్యులేట్ చేసి d కి ఇస్తుంది. ఆ తర్వాత, a వాల్యూ ఒకటి తగ్గి 16 అవుతుంది.

#include<stdio.h>

int main()
{
     int a=10,b,c,d;

     b=a++ + a++ + a++;
     printf("%d %d\n",a,b);
     c=++a + ++a + ++a;
     printf("%d %d\n", a, c);
     d=++a + a--;
     printf("%d %d\n",a,d);

  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ
ఈ ప్రోగ్రాం లో postfix, prefix ఆపరేటర్లను మామూలుగా, అంటే ఏ expression లోనూ కాకుండా వాడాం. వీటినే standalone statements అని అంటారు. అప్పుడు postfix, prefix కు మధ్య ఏ వ్యత్యాసం ఉండదు. అంటే a++ లేక ++a అనేవి రన్ అయిన తర్వాత a వాల్యూ ఒకటిగా ఉంటుంది. దీనిని ఈ కింద వివరించిన ప్రోగ్రాం ద్వారా తెలుసుకుందాం.

#include<stdio.h>

int main()
{
     int a=10,b=10;

     a++;
     ++b;

     printf("%d %d\n",a,b);

  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ఉదాహరణ

ఈ కింది ప్రోగ్రాం 0, 0 ను రిజల్ట్ లాగా ఇస్తుంది. ఎందువల్ల?

#include<stdio.h>

int main()
{
     int a=0,b=0,c,d;

     c=(a++&&b++);
     d=(b&&++c);


     printf("%d %d\n",c,d);

  return (0);
}

పై ప్రోగ్రాం రిజల్ట్ ఈ విధంగా ఉంటుంది.

     

ముందుగా లాజికల్ ఆపరేటర్ && గురించి గుర్తుకు తెచ్చుకోవాలి. దీనిని ఎవాల్యుయేట్ చేస్తున్నప్పుడు మొదటి ఆపరాండ్ ఫాల్స్ అయితే రెండోది ఎవాల్యుయేట్ అవదు. ఎందుకంటే అది ట్రూ అయినా ఫాల్స్ అయినా రిజల్ట్ ఫాల్స్ అవుతుంది. అందువల్ల, ఈ ప్రోగ్రాంలో c=(a++&&b++); ఎవాల్యుయేట్ చేస్తున్నప్పుడు a సున్నా అయినందువల్ల c వాల్యూ సున్నా అవుతుంది. b++ రన్ అవదు. కాబట్టి b వాల్యూ సున్నాగానే ఉంటుంది. అలాగే, d=(b&&++c); ఎవాల్యుయేట్ చేస్తున్నప్పుడు b సున్నా కాబట్టి, లాజికల్ ఆపరేటరు రిజల్ట్ సున్నా అవుతుంది. కాబట్టి d కూడా సున్నా అవుతుంది.

NB Venkateswarlu
M.Tech(IIT-Kanpur)
Ph.D (BITS),PDF(UK),
Sr.Prof., CSE, AITAM, Tekkali

  • Industry      Interaction

    Higher Education

    Job Skills

    Soft Skills

    Comm. English

    Mock Test

    E-learning