మాడ్యూల్ 8 కు ప్రోగ్రామింగ్ C ++ లో స్వాగతం.
మేము ముందు భాగం లో ఈ మాడ్యూల్ గురించి చర్చిస్తున్నాము మరియు మేము డిఫాల్ట్ పారామితులు( default parameters) గురించి మాట్లాడారు.
ఇప్పుడు, మనం ఫంక్షన్ ఓవర్లోడింగ్( function overloading) గురించి చర్చిస్తాం.
ఫంక్షన్ ఓవర్లోడింగ్ ను అర్ధం చేసుకోవటానికి, మొదట ఒక ఫంక్షన్ ఓవర్లోడింగ్( function overloading) వంటిది ఎందుకు అవసరమో మరియు అది అర్థం కావచ్చని ఎందుకు వివరించాలో మనకు ఉదాహరణగా తీసుకుంటాము.
కాబట్టి, ఇక్కడ C.
లో ఒక ఉదాహరణ.
ఇది మాత్రికలను గుణించడం, మ్యాట్రిక్స్లతో వెక్టర్లను( vectors) గుణించడం లేదా వెక్టర్లను గుణించాలి.
కాబట్టి, ఇక్కడ ఇచ్చిన నిర్వచనాలకు మీరు కొద్దిగా జాగ్రత్తగా చూస్తే, ముందుగా మేము మూడు రకాలను నిర్వచించాము, ఇవి అలియాస్.
మాట్రిక్స్( matrix) ఈ రెండు ఉదాహరణలలో మనము తీసుకున్న ద్వి-మితీయ చతురస్ర మాత్రిక( two dimensional square matrix).
అప్పుడు, రెండవ VecRow లో.
ఈ VecRow లో ఒక వరుస వెక్టర్ మరియు VecCol కాలమ్ వెక్టర్.
కాబట్టి, మీరు వీటిని అర్ధం చేసుకోవచ్చు.
ఈ మీరు ఈ చూడవచ్చు.
కాబట్టి, ఈ మూడు రకాలు మరియు, మనకు కావలసినది ఏమిటంటే అది మాత్రిక గుణకారం యొక్క నియమావళి ద్వారా నిర్వచించబడుతుంది, వాటిని గుణించటానికి ఫంక్షన్ రాయాలనుకుంటున్నాము.
మొదటి ఫంక్షన్ రెండు మాత్రికలను గుణిస్తే మరియు ఫలితం మాత్రికను అందిస్తుంది.
'మ్యాట్ ఎ' చతురస్ర మాత్రిక a( square matrix a), 'Mat b' మరొక చతురస్ర మాత్రిక మరియు వాటిలో రెండింటి పరిమాణం 10 అని మీరు సులభంగా చూడవచ్చు.
కాబట్టి, నేను వాటిని గుణించి ఉంటే, నేను మరొక చతురస్ర మాత్రిక c( square matrix c) ను పొందుతాను నియమాలు మరియు మీరు ఈ సి చేస్తున్నప్పటి నుండి, విలువ ద్వారా కాల్, మేము ఈ ఫంక్షన్(function) నుండి అవుట్పుట్(output) పొందడానికి గమనికలు ఉపయోగించడానికి అవసరం.
ఇప్పుడు, నేను ఒక గుణకారం నిర్వచించాలనుకుంటున్నాను, ఇది ఒక చతురస్ర మాత్రిక 'a' మరియు ఒక నిలువు వెక్టర్ b(column vector) 'మధ్య ఉన్న రెండవది.
నేను అలా చేస్తే సహజంగానే నేను కాలమ్ వెక్టార్ను( column vector c) పొందుతాను.
ఇప్పుడు మనం మరల్చిన నియమాలపై పునశ్చరణ చేస్తే, మీకు మాడ్రిసీస్ గుణించినా, మీకు తెలిసిన వారందరికి తెలిసిన వరుసల కాలవ్యవధి మరియు ఇక్కడ వివరించడానికి నాకు అవసరం లేదు.
మీరు రెండు మాత్రికలను గుణించడం లేదా ఒక మ్యాట్రిక్స్ను గుణించడం లేదా ఒక చదరపు మాత్రికను ఒకే పరిమాణం యొక్క నిలువు వెక్టర్తో గుణించడం మధ్య ఏదైనా తేడా లేదని మీకు తెలుస్తుంది.
మీ ఫలితంగా వ్యత్యాసం మాత్రమే కాలమ్ వెక్టర్( column vector) అవుతుంది మరియు మీరు కొనసాగితే, మేము మూడవ వైపు చూస్తే, ఇది వరుసగా వెక్టర్ ద్వారా మాత్రిక యొక్క ముందస్తు గుణకం అవుతుంది.
మీరు నాల్గవ రూపాన్ని చూస్తే, అది ఒక వరుస వెక్టర్ ద్వారా ఒక నిలువు వెక్టర్ యొక్క గుణకారం అవుతుంది, దాని ఫలితం చతురస్ర మాత్రికగా( square matrix) మారుతుంది మరియు ఐదవ వంతులో, మీరుసి 'ను పొందుతారు, ఒక రో వెక్టర్ ( row vector)గుణకారం ఒకే విలువగా ఉంటుంది.
ఇప్పుడు, ఇదే అన్ని గుణకారం కోసం అదే అల్గోరిథంను( algorithm) అనుసరిస్తుంది, కానీ నేను వాటిని వ్యక్తీకరించాలనుకుంటే, వాటిని C భాషలో కోడ్ చేయండి, నేను అన్ని వేర్వేరు పేర్లను అందించాలి.
మీరు ఈ భాగాన్ని చూస్తే, ఈ ఫంక్షన్లకు వివిధ పేర్లను నేను అందించాలి ఎందుకంటే అవి వేర్వేరు విధులు.
వారు విభిన్న రకాల పద్ధతులను తీసుకుంటారని, వాళ్ళందరూ మూడు వాదనలు తీసుకుంటారని, ఎందుకంటే సంభావ్యంగా వారు a మరియు b మాట్రిక్స్( matrices) తీసుకొని గుణించడం మరియు ఫలితాన్ని c' ఇవ్వడం జరుగుతుంది.
కానీ ఈ అన్ని వేర్వేరు రకాలు ఎందుకంటే, నేను ఈ ఫంక్షన్ ఇచ్చిన వేర్వేరు పేర్లు కలిగి ఉండాలి మరియు నేను ఉపయోగిస్తున్నప్పుడు, నేను మాత్రమే నేను ప్రయాణిస్తున్న ఏమి వివిధ పారామితులు(parameters) అర్థం కానీ అంటే rv ఒక వరుస వెక్టర్ m2 'ఒక మాట్రిక్స్( matrix).
కాబట్టి, నేను వరుసగా వెక్టర్ మరియు మ్యాట్రిక్స్ ను ఉపయోగిస్తానంటే, నా పేరు ఫంక్షన్ multiply_VR_M లేదా ఇలాంటిదే.
ఒక రో వెక్టార్( row vector) ద్వారా వరుస వెక్టర్ యొక్క గుణకారం చేస్తున్నట్లయితే, అప్పుడు ఫంక్షన్ యొక్క పేరు వేరొక ఉదా.
Multiply_VR_VC ఉండాలి.
కాబట్టి, మీరు ఈ పరిశీలనలను సంక్షిప్తం చేస్తే, మీరు అర్థం చేసుకునేది ఐదు మల్టిపులేషన్ ఫంక్షన్లు ( multiplication function) ఇక్కడ చూపించాము, అదే కార్యాచరణను భాగస్వామ్యం చేయండి.
అవి ఒకే అల్గారిథమ్ని( algorithm) కలిగి ఉంటాయి, కానీ వాటికి ఐదు వేర్వేరు వాదన రకాలు మరియు ఫలితాల రకాలు ఉన్నాయి మరియు పర్యవసానంగా సి వాటిని ఐదు వేర్వేరు ప్రత్యేక విధులుగా పరిగణిస్తుంది.
ఇప్పుడు, C ++ అదృష్టవశాత్తూ ఈ పరిస్థితికి ఒక సొగసైన పరిష్కారం ఉంది, అదే విధమైన కార్యాచరణను కలిగి ఉన్న వేర్వేరు విధులు అవి అదే అల్గోరిథంను ఉపయోగిస్తాయి లేదా అవి ఒకే అల్గోరిథం యొక్క కొద్దిగా భిన్నమైన వైవిధ్యాలను ఉపయోగిస్తాయి, కానీ ఖచ్చితంగా వివిధ రకాలైన డేటా టైప్స్( data types) వాదన ఇప్పుడు వారి ఫంక్షన్ పేరు భాగస్వామ్యం మరియు మొత్తం ప్రోగ్రామింగ్ ( programming) వ్యాయామం చాలా సులభం చేయవచ్చు.
కాబట్టి, ప్రారంభించండి, అదే ఉదాహరణతో కొనసాగుతుంది, ఇప్పుడు ఇది మళ్ళీ C ++ లో కోడ్ చేయబడింది.
కేవలం ప్రధాన తేడాలు చూడండి.
మొదటి మీరు టైప్డేఫ్( typedef) త చేసినపుడు చూస్తే, అవి ఒకేలా ఉంటాయి.
మేము అదే రకాలు వ్యవహరిస్తున్నాం.
మీరు ఐదు విధులను చూస్తే, మనము అదే ఐదు ఫంక్షన్లు కలిగివుండటం వలన, మొదటిది ఇప్పటికీ రెండు మాత్రికలను గుణించి, రెండవది ఒక మాత్రికను గుణించి, పోస్ట్ను ఒక కాలమ్ వెక్టర్తో( column vector) ఒక మ్యాట్రిక్స్ను గుణించి, కానీ మీరు పేర్లను పరిశీలిస్తే, మీరు చాలా భిన్నమైనదాన్ని చూస్తారు.
మీరు వాటిని ఒకే పేరు కలిగి ఉన్నారని మీరు చూడవచ్చు, మీరు C లో చేయలేకపోతున్నారని, మేము ఆ ఫంక్షన్ పేర్లను ప్రపంచంగా చెప్పాము.
ఇవి గ్లోబల్ చిహ్నాలు( global symbols) .
కాబట్టి, C ప్రోగ్రామ్ యొక్క మొత్తంలో, మీరు వ్రాసే మరియు ఎన్ని ఫైళ్ళతో( files) సంబంధం లేకుండా, ఒక ప్రోగ్రామ్కు ఒక ప్రదేశంలో ఒక యూనిట్ వలె అమలు చేసే ప్రోగ్రామ్ మొత్తంలో, ప్రతి ఫంక్షన్ పేరు వేరుగా ఉంటుంది, ఫంక్షన్ పేరు.
మీరు ఒక్కో ఫంక్షన్ పేరు కోసం ఒక్కో ఫంక్షన్ పేరుని వ్రాయవచ్చు, కానీ ఇక్కడ మీరు ఐదు వేర్వేరు ఫంక్షన్లను ఒకే పేరుతో పంచుకున్నారని మీరు చూడవచ్చు, కాని కోర్సులో మీరు ఇక్కడ ఉన్నటువంటి వాటి పారామీటర్లను( parameters) చూస్తే, వాటిలో ఏ రెండు పారామితులను కలిగి ఉన్నాయని మీరు కనుగొంటారు.
వారు నిజంగా అవసరం లేదు, ఎందుకంటే మొదటి గుణాన్ని వేరుచేస్తుంది, ఇది రెండు మాత్రికలను (two matrices) గుణించి, మరొక చతురస్ర మాత్రిక ద్వారా ఇవ్వబడుతుంది, ఇది ఒక మాడ్రిక్స్ను ఒక కాలమ్ వెక్టర్తో ఒక మాత్రికను వెక్టర్తో పెంచడం లేదా మూడవది అడ్డు వరుస వెక్టర్ కలిగిన మ్యాట్రిక్స్ రో వెక్టర్( row vector) ఇవ్వడం.
వాటిలో అన్నిటికీ విభిన్నమైనవి, వాదనలు కోసం వారి సంబంధిత విభిన్న డేటా టైప్స్ ( data types) అర్గుమెంట్స్( arguments).
ఇప్పుడు మనము చేసిన చిన్న విషయం మాడ్యూల్ 6 మరియు 7 లో మనము పెద్ద ఆబ్జెక్ట్లలో కాల్ బై రిఫరెన్స్ (call by reference) మెట్రిసిస్ ద్వారా కాల్ ను ఉపయోగించామని నేర్చుకున్నాము.
కాబట్టి, మీరు వాటిని విలువగా మరియు వాటిని కాపీ చేయకూడదనుకుంటున్నాము, మనం వాటిని సూచనగా పాస్ చేయాలనుకుంటున్నాము మరియు ఇన్పుట్ మాత్రికలు (input matrices) లేదా వెక్టర్స్ ఫంక్షన్లో నిశితంగా లేదని నిర్ధారించుకోవాలి.
మేము ఆ పారామితులను నిరంతరం చేస్తాము, అవుట్పుట్( output) వైపున మేము కేవలం సూచన విధానాల ద్వారా కేవలం కాల్ని ఉపయోగిస్తాము, తద్వారా మనకు పరోక్ష పాయింటర్ ( pointer) భాగం అవసరం లేదు, అయితే ఇది కేవలం ఐదు పాయింట్లు అదే పేరు మరియు ఈ ఐదు వాటిని అదే పేరుతో సంబంధిత ఆక్చువల్ పారామితులు( actual parameters) ద్వారా ఉపయోగించవచ్చు.
కాబట్టి, ఏమి జరుగుతుందో నేను ఒక మాత్రిక యొక్క పోస్ట్ గుణకారం కాలమ్ వెక్టర్తో ( column vector) చేయటానికి ప్రయత్నిస్తాను అనుకుందాం, కాబట్టి నేను ఒక matrixm1 'ను కలిగి ఉన్నాను, నేను ఒక కాలమ్ వెక్టర్cv ను కలిగి ఉన్నాను మరియు నేను వాటిని గుణించి ఉంటే, నేను ఏమి పొందాలి? నేను ఒక కాలమ్ వెక్టార్ కావాలి.
కాబట్టి, ఫలితంగా నేను కాలమ్ వెక్టార్rcv 'ను ఊహించాను.
కాబట్టి నేను చెప్పేదేమిటంటే, నేను గుణించాలి; నేను m1 ను మ్యాట్రిక్స్గా, cv' ని కాలమ్ వెక్టర్గా మరియు rcv ను నా ఫలితం మాత్రికగా( result matrix) ఉంచాను.
ఇప్పుడు, ఏదో ఒకవిధంగా నేను దీనిని చేస్తే మరియు నేను ఆ ప్రత్యేక ఫంక్షన్ను సరిగ్గా పిలుస్తాను; పోస్ట్ ఒక చదరపు మాత్రికను నిలువు వెక్టర్తో గుణిస్తుంది.
కాబట్టి, ఈ ఫంక్షన్లలో మీరు ఈ పారామితులను పేర్కొనడం చాలా ఆసక్తికరంగా, అప్పుడు ఆసక్తికరంగా ఇది వాస్తవానికి ఈ ఫంక్షన్ అని పిలుస్తుంది.
అయినా ఐదు విధులు ఉన్నాయి, వాటిలో అన్ని గుణించాలి మరియు నేను ఈ ఫంక్షన్ను కూడా గుణిస్తున్నట్లు పిలుస్తాను, కానీ ఏదో విధంగా, పారామితులను నేను అర్థం చేసుకోగలుగుతాను.
ఈ పారామితుల యొక్క రకాలు, ఈ పరామితి యొక్క రకము ఇక్కడ సరిపోతుంది, ఇక్కడ రెండవ పరామితి యొక్క రకం పారామితిcv 'is' VecCol ', ఇది ఇక్కడ సరిపోతుంది మరియు మూడవ పారామితి rcv రకం' VecCol ' ఇక్కడ సరిపోతుంది.
మనము ఈ 5 పారామితులు తమ టైప్లో సరిపోలుతున్నాము మరియు కంపైలర్ ( compiler)ఈ ప్రత్యేక ప్రవేశానికి చెందిన రెండవ ఫంక్షన్కు కాల్ చేయగలదు అని మేము కనుగొన్నాము.
అదేవిధంగా, నేను ఈ పరిశీలిస్తే, ఈ 3 పారామితుల రకాన్ని బట్టి, కంపైలర్ నిజానికి ఈ ఫంక్షన్కు కాల్ చేయవచ్చు, ఎందుకంటే rv is VecRow , rcv' is 'VecCol' మరియు r .
rv ',cv,r ',` vecRow', 'VecCol', int మాత్రమే ప్రత్యేకంగా చివరి పని అని పిలుస్తారు ఇది పని చేస్తుంది.
కాబట్టి, ఈ 5 ఫంక్షన్స్ విభిన్న ఆర్గ్యుమెంట్ రకాలను (argument types) కలిగి ఉంటాయి, కాని అవి C ++ లో ఒక సాధారణ పేరు కలిగిన ఒక ఫంక్షన్గా వ్యవహరిస్తారు మరియు ఈ లక్షణం చాలా శక్తివంతమైనది మరియు ఇది చాలా విషయాలు చేయడాన్ని మనం ఫంక్షన్ ఓవర్లోడింగ్( function overloading) లేదా అని నెమ్మదిగా ఒక ప్రత్యామ్నాయ పేరు అర్థం, ఇది మరింత ప్రామాణికమైన పేరు స్టాటిక్ పాలిమార్ఫిజం (static polymorphism).
సో, మేము ఫంక్షన్ ఓవర్లోడింగ్ సులభంగా ఉంటుంది ఎందుకు ప్రేరణ చూసింది.
మేము ఐదు వేర్వేరు ఫంక్షన్లకు ఐదు వేర్వేరు ఫంక్షన్లకు ఇచ్చాము, వారి ప్రధాన కార్యాచరణ, కోర్ అల్గోరిథం ఇంకా ఒకేలా ఉండటంతో మేము ఈ పరిస్థితిని గమనించాము మరియు ఈ పేర్లను స్పష్టంగా గుర్తుంచుకోవాలి, C ++ లో మనకు ఓవర్లోడింగ్ పేరు మరియు ఫంక్షన్ యొక్క మా కాల్ లేదా ఉపయోగం ఆధారంగా, సరైన ఫంక్షన్ అని మేము అని చూసిన ప్రత్యేక కాల్ కట్టుబడి ఉంటుంది.
కాబట్టి, ఇప్పుడు మనం ముందుకు వెళ్లి, వివిధ రకాల ఫంక్షన్లను C ++ లో ఎలా ఓవర్లోడింగ్ చేస్తామో చూద్దాం.
కాబట్టి, ఫంక్షన్ ఓవర్లోడింగ్ లో, మేము అదే పేరుతో ఉన్న బహుళ ఫంక్షన్లను నిర్వచిస్తాము ఎందుకంటే మీరు ఒకే పేరుతో ఒకటి కంటే ఎక్కువ ఫంక్షన్ కలిగి ఉంటే, ఓవర్లోడింగ్ (over loading) యొక్క సమస్య తలెత్తదు మరియు రెండవది బైండింగ్ (binding) జరుగుతుంది కంపైల్ రకం వద్ద.
బైండింగ్ ఫంక్షన్( binding function) కాల్ ఇచ్చిన ఒక అధికారిక పదం, మీరు ఏ నిర్దిష్ట ఫంక్షన్ నిజానికి పిలుస్తారు మరియు ఆ ప్రక్రియ బైండింగ్ అని పిలుస్తారు ఎలా నిర్ణయిస్తారు.
ఈ కంపైలర్ ఏమి ఉంది.
కాబట్టి, కంపైల్ సమయంలో బైండింగ్ అంటారు.
ఇప్పుడు మనము దీనిని పరిశీలిద్దాము.
రెండు నిలువు వరుసలలో, మనము ఇక్కడ రెండు వేర్వేరు రకాలైన సందర్భాలను చూపుతాము.
ఇక్కడ ఫంక్షన్ జోడించు యొక్క ఓవర్లోడింగ్ ను చూపుతుంది, ఇక్కడ మొదటి ఉదాహరణ, మీరు పారామితులపై ప్రత్యేకంగా దృష్టి సారిస్తారు.
జోడించు 'రెండు ఇంటిజర్ పారామితులను ( integer parameters)తీసుకుంటుంది మరియు రెండో సందర్భంలో ఇంటిజర్ను తిరిగి ఇస్తుంది, అది రెండు డబుల్ పారామీటర్లను ( double parameters)తీసుకుంటుంది మరియు డబుల్ను అందిస్తుంది.
కాబట్టి, మనము 'జోడించు' ఫంక్షన్ ను వ్రాయటానికి ప్రయత్నిస్తున్నాము, ఇది సంభావ్యంగా రెండు సంఖ్యలను జతచేయాలి, కానీ C లో అది C ++ లో కూడా ఉంటుంది, అది జోడించే సంఖ్యల ఇంట్ లేదా అవి డబుల్ లేదా అవి ఇంకేదో.
ఇప్పుడు, నేను ఈ రెండు ఫంక్షన్లను ఒకే కోడ్లో వ్రాయగలను మరియు తరువాత రెండు వేర్వేరు ప్రదేశాలలో నేను ఉపయోగిస్తున్నాను.
ఇక్కడ నేను x(y,y)ను జోడించు ఉపయోగిస్తున్నాను, ఇక్కడ x ఒక ఇంట్ మరియు y ఒక ఇంట్ .
కాబట్టి, ప్రధానంగా, నేను 'చేర్చు' కాల్ చేస్తున్నాను రెండు పారామితులు.
అందువల్ల, ఈ కాల్ రెండు పారామితుల కొరకు పనిచేస్తుంది అనగా యాడ్ యొక్క ఈ నిర్వచనానికి కట్టుబడి ఉంటుంది, అయితే మీరు టైప్ డబుల్( type double)యొక్క s మరియు t 'ను ఉపయోగించే యాడ్ ఫంక్షన్( add function) యొక్క రెండవ కాల్ని పరిశీలిస్తే, మా పరామితి రకాలు డబుల్( parameter types double) మరియు డబుల్ కంపైలర్ ( double compiler)ఈ కాల్ వాస్తవానికి జోడింపు ఫంక్షన్ యొక్క రెండవ నిర్వచనం కోసం అని గుర్తించడానికి మరియు అక్కడ అది కట్టుబడి ఉంటుంది.
దీని ప్రకారం, మొదటిది సంకలనం 11 ను ముద్రిస్తుంది మరియు రెండవ కాల్ మొత్తం 7.
75 ను ముద్రిస్తుంది.
మనము అన్ని రకాల డేటాను ఉపయోగిస్తున్నామనేది మనకు తెలుసు కాబట్టి మీరు ఏ విధమైన డేటాను ఉపయోగిస్తున్నారంటే ఎందుకంటే నేను రెండు ఇంటిజర్లను జోడించాను, నేను ఒక విధమైన అదనంగా ఉన్నాను.
నేను రెండు డబుల్స్ని జోడించాను, నాకు వేరే రకమైన అదనంగా ఉంటుంది.
కాబట్టి, ఈ భాగంలో మనము రెండు సందర్భాలలో 'యాడ్' అనే పారామితులను కలిగి ఉన్న పారామితుల సంఖ్య, కానీ పారామితుల యొక్క రకాలు భిన్నంగా ఉంటాయి మరియు దాని ఆధారంగా మేము ఒక ప్రత్యేక కాల్ మాట్లాడుతున్నాము గురించి, కాల్ నుండి, ఓవర్లోడ్ చేసిన వేరే ప్రత్యామ్నాయాల యొక్క నిర్దిష్ట ఫంక్షన్ వాస్తవానికి ప్రయోగించాల్సిన అవసరం ఉంది, వాస్తవానికి కట్టుబడి ఉండాలి.
ఇప్పుడు, ఓవర్లోడింగ్ కోసం ఇది అవసరం లేదు.
ఇప్పటివరకు, మనము ఐదు మల్టిపుల్ ఫంక్షన్లు( multiple function) లేదా ఇక్కడ ఫంక్షన్లను జతచేసిన అన్ని ఉదాహరణలు, అన్ని సందర్భాలలో పరామితుల సంఖ్య ఒకే విధంగా ఉంటుంది, కానీ ఫంక్షన్ ఓవర్లోడింగ్( function overloading) కోసం ఇది తప్పనిసరి కాదు.
సో, కుడి కాలమ్ చూడండి.
తదుపరి ఉదాహరణ, ఇక్కడ మేము రెండు విధులు ఏరియా చూపుతాము.
మొదటిది ఒక దీర్ఘ చతురస్రం యొక్క ప్రాంతాన్ని లెక్కించడానికి ఉద్దేశించబడింది.
కాబట్టి, అది వెడల్పు మరియు ఎత్తు యొక్క రెండు పారామితులను తీసుకోవాలి, వాటిని గుణించాలి మరియు వ్రాసినప్పుడు, రెండోది ఒక పరామితిని మాత్రమే తీసుకుంటుంది, ఎందుకంటే అది ఒక చదరపు ప్రదేశంను లెక్కించవలసి ఉంటుంది, కాబట్టి మీరు ఆ సంఖ్య మరియు చతురస్రాలు ఆ సంఖ్య మరియు వ్రాసినది.
కాబట్టి, ఈ రెండు విధులు మధ్య, పేరు అదే ఉంది.
దీనికి రెండు పారామీటర్లను కలిగి ఉంది, దీనికి ఒక పరామితి ఉంది మరియు మేము 'Area(x,y)అని పిలిచినట్లయితే మనం ఈ పనితో ఇంకా పనిచేయగలము అని క్రింద చూద్దాం, అప్పుడు ఒక ఫంక్షన్ ఉందని మాకు తెలుసు.
ఈ ఫంక్షన్లో ఒకటి, ఈ రెండు పారామీటర్లను కలిగి ఉంది, పారామితి ఇక్కడ x గా ఉంది, పారామీటర్ Y కూడా Int.
కాబట్టి, ఇది (Int,Int) కాల్.
కాబట్టి, రెండు పారామితులు( two parameters), టు ఇంటిజర్స్( two integers) ఉండాలి.
వారు నిజంగా ఇక్కడ పూర్ణ సంఖ్య.
కాబట్టి, ఈ కాల్ వాస్తవానికి మొదటి ప్రాంతం ఫంక్షన్ను ఇన్వోక్ చేస్తుంది.
దీనికి విరుద్ధంగా మేము రెండవ కాల్ని పరిశీలిస్తే, ఒక పారామితి z ఉంది, ఇది రకం Int.
ఇది ఒక పరామితి కలిగిన రెండో ఏరియా ఫంక్షన్కు కట్టుబడి ఉంటుంది.
కాబట్టి, వేర్వేరు విధులు ఓవర్లోడ్ చేయబడినవి, పారామితుల యొక్క వేర్వేరు సంఖ్యలో ఉన్నప్పుడు కూడా పిలువబడతాయి.
పరామితుల సంఖ్య భిన్నంగా ఉన్నప్పటికీ గమనించండి, ఇక్కడ మొదటి పరామితి పరంగా, రకం అదే ఉంది.
మునుపటి సందర్భాలలో, మునుపటి సందర్భాలలో అదే పారామితుల సంఖ్య.
వివిధ రకాలుగా మీరు క్లూను మీకు ఇచ్చే హక్కును కాల్ చేస్తున్నప్పుడు, ఇక్కడ రకం అతివ్యాప్తి అయినప్పటికీ సంఖ్యలు భిన్నంగా ఉంటాయి.
మీరు ఇంకా సరైన పరిష్కారం కోసం సరైన కార్యాచరణను బంధించగలిగారు, ఇప్పటికీ పరిష్కరించగలుగుతారు.
సో, మీరు ఫంక్షన్ ఓవర్లోడింగ్ గురించి మాట్లాడేటప్పుడు, మనం ప్రాథమికంగా మాట్లాడతాము, అక్కడ ఒకటి కంటే ఎక్కువ ఫంక్షన్లు వుంటాయి మరియు ఈ విధులు కొంతవరకు వాటి కార్యాచరణలో ఉంటాయి.
ఇప్పుడు, మీరు ఫంక్షన్తో స్క్వేర్ రూట్ చేయడానికి పది సంఖ్యలను క్రమం చేయడానికి ఫంక్షన్ను ఓవర్లోడ్ చేయలేరు.
నేను మీరు వాటిని ఎల్లప్పుడూ పిలవగలరు; నేను నా పేరును myfunc మరియు myfunc అనే ఓవర్లోడ్(overload) చేస్తాను, పారామీటర్ డబుల్ ఉంటే, అప్పుడు అది చదరపు రూటును కనుగొంటుంది మరియుmyfunc 'కి పరామితి ఉంటే అది క్రమం చేస్తుంది.
ఇది ఓవర్లోడింగ్ నియమావళికి అనుగుణంగా పనిచేస్తుంది, మీరు దీన్ని చేయగలుగుతారు, కానీ ఖచ్చితంగా ఇది ఈ లక్షణం యొక్క విపత్తు ఉపయోగంగా ఉంటుంది.
కాబట్టి, మేము ఓవర్లోడ్ చేస్తే ప్రాథమిక భావనీకరణ అనేది అన్ని ఓవర్లోడ్ చేయబడిన ఫంక్షన్లు చాలా సంబంధిత కార్యాచరణను కలిగి ఉండాలి.
వారు చాలా పోలి అల్గోరిథంలు( algorithms) గురించి మాట్లాడటం ఉండాలి, కానీ వారు ఉపయోగించే పారామితుల యొక్క రకాలు, గణన చేయడం కోసం వారు ఉపయోగించే పారామితుల యొక్క సంఖ్య వేరుగా ఉంటుంది, తద్వారా నేను ఈ విధమైన అన్ని పనులకు ఇదే ఇవ్వగలదు మరియు C ++ లో పనిచేసే పనితీరు ఓవర్లోడ్ చేయాల్సిన విధానం ఫంక్షన్ ఓవర్లోడింగ్( function overloading) పరంగా కొన్ని పరిమితులు ఉన్నాయి.
ఫంక్షన్ ఓవర్లోడింగ్ ప్రాధమికంగా ఫంక్షన్ యొక్క సంతకంపై ఆధారపడి నిర్ణయించబడింది, ప్రతి సందర్భంలో మేము, సి లో, మీరు రెండు విధుల మధ్య ఎలా పరిష్కరించాలో, మేము మాట్లాడుతున్నాము.
వారు వివిధ పేర్లు, వేర్వేరు విధులు కలిగి ఉండాలి.
C ++ లో, రెండు విధులు లేదా రెండు కంటే ఎక్కువ విధులు ఒకే పేరును కలిగి ఉంటాయి.
ఎలా మీరు పరిష్కరించాలి? మేము అనేక ఉదాహరణలు చూసిన పరామితుల రకాలను బట్టి, పారామితుల సంఖ్య ఆధారంగా వారి సంతకాల ఆధారంగా మీరు పరిష్కరించాలి.
ఇప్పుడు, ప్రశ్న, నేను కలిగి రెండు విధులు ఉంటే; ఇక్కడ మనము ఈ ప్రత్యేక కేసుని చెక్ చేద్దాము, నాకు రెండు విధులు ఉన్నాయి.
మరోవైపు, రెండూ ఒకే పారామితుల సంఖ్యను ఉపయోగిస్తాయి, వాటిలో రెండూ ఒకే విధమైన పారామితులను (int,int)మరియు(int,int) మరియు వాటి పూర్ణాంకాలకు భిన్నంగా ఉంటాయి.
ఇప్పుడు, ఇటువంటి రకమైన విధులు కలిసి ఉపయోగించలేరని దయచేసి గమనించండి.
ఫంక్షన్ ఓవర్లోడింగ్ ( function overloading)పరంగా ఇది సాధ్యం కాదు.
కాబట్టి, బహుశా ఇది ఇక్కడ చూపించబడింది, ఇది ఒక కంపైలర్ నుండి ఒక సాధారణ ఎర్రర్( error)సందేశం, ఇది ఇక్కడ చెప్పబడుతుందని మీకు చూపిస్తుంది, ఇది మొదటి చర్యను సరే, మీరు ప్రయత్నిస్తున్నప్పుడు రెండవ ఫంక్షన్ను కంపైల్ చేయడానికి ప్రయత్నించినప్పుడు , అది రెండవ డ్యూటీ టైప్ గురించి మాట్లాడటం ఎందుకు అంటే ఇది ఓవర్లోడ్ అయిన ఫంక్షన్ తిరిగి టైప్ చేస్తే భిన్నంగా ఉంటుంది.
ఇది తిరిగి టైప్ ద్వారా మాత్రమే భిన్నంగా ఉంటుంది మరియు అది అనుమతించబడదు మరియు అందుకే ఈ పునర్నిర్వహణగా పరిగణించబడుతున్నాయి, మీరు ఈ ఫంక్షన్ని మీరు ఇదే విధమైన సంస్కరణను పునర్నిర్వచించటం ఉంటే మీరు ఈ ఉదాహరణను C.
ఇదే విధమైన ఎర్రర్ సందేశాన్ని కూడా కనుగొంటుంది ఎందుకంటే ఇది ఒక పునర్నిర్వచనా సందేశం.
మొదటి సందేశము ఏమిటంటే ఫంక్షన్ ఓవర్లోడింగ్ పాయింట్ దృక్పథం నుండి విలక్షణమైనది మీరు రెండు పారామీటర్ల సంఖ్యను భిన్నంగా లేదా పరామితుల సంఖ్యను కొనసాగించకపోయినా, రెండు విధులు ఓవర్లోడ్ చేయలేవు, కానీ ఇప్పటికీ వాటి సంతకాలు ఉంటే పరామితుల యొక్క రకాలు కనీసం విభిన్నంగా ఉంటాయి రిటర్న్ టైప్ (return rype )లో కేవలం భిన్నంగా ఉంటాయి, అప్పుడు ఓవర్లోడింగ్ అనుమతించబడదు.
కాబట్టి, మీరు ఈ పరిమితిని మీరు వ్యవహరించేటప్పుడు గుర్తుంచుకోండి, మీరు ఓవర్లోడ్ చేయబడిన విధులను వ్రాసేటప్పుడు.
ఫంక్షన్ ఓవర్లోడింగ్ కొరకు మనకు ఉన్న నియమాల పరంగా మొత్తమ్మీద అదే ఫంక్షన్ పేరు అనేక నిర్వచనాలలో ఉపయోగించబడుతుందని చెప్పబడుతుంది.
ఇది ప్రాథమిక ఓవర్లోడింగ్ భావన.
అదే పేరుతో ఉన్న ఫంక్షన్ అధికారిక పారామితులు మరియు / లేదా రెండు రకాల ఉదాహరణలుగా ఉండే మాదిరి పారామితులను వేర్వేరు రకాలను కలిగి ఉండాలి.
ఫంక్షన్ ఎంపిక అసలు పారామితుల యొక్క సంఖ్య మరియు రకాలు మీద ఆధారపడి ఉంటుంది.
మేము ఇక్కడ కూడా ఉదాహరణలు చూశాము.
అప్పుడు, కంపైలర్ చేత చేయబడిన ఈ ఫంక్షన్ ఎంపిక ఓవర్లోడ్ స్పష్టత అంటారు.
దీని అర్థం, మీరు బహుళ విధులు ఓవర్లోడ్ చేయబడ్డారు.
అదే పేరుతో బహుళ విధులు మరియు మీకు ఒక కాల్ సైట్ ఇవ్వబడుతుంది; మీరు ఈ బహుళ అభ్యర్థులలో ఏది ఉపయోగించాలో గుర్తించడానికి ప్రయత్నిస్తున్న ఒక కాల్కి మీరు ఇస్తారు.
ఆ ప్రక్రియ ఓవర్లోడింగ్ కోసం తీర్మానం ప్రక్రియ అని పిలువబడుతుంది, C ++ కంపైలర్ నిర్వహిస్తుంది మరియు ఓవర్ టైం, ఇది నిజానికి చాలా సంక్లిష్టమైన ప్రక్రియ మరియు చాలా శక్తివంతమైన ప్రక్రియ అని మీరు అర్థం చేసుకుంటారు మరియు ఆ ప్రక్రియ ద్వారా కంపైలర్ మీరు ఉపయోగించబోయే ఓవర్లోడ్ వెర్షన్లు లేదా మీరు కాల్ సైట్లో ఉపయోగించడానికి ఉద్దేశించి, కంపైలర్ అలా అనిపిస్తే.
రెండు విధులు ఒకే సంతకం అయితే వివిధ తిరిగి రకాలు లేదా కొన్ని ఇతర కారణాల వలన పరామితి రకాలు భిన్నంగా ఉంటాయి, కానీ కంపైలర్ పరిష్కరించడానికి సరిపోదు.
కంపైలర్ అలా చేయలేకపోతే, కంపైలర్ మీరు తిరిగి ప్రకటించాలని ప్రయత్నిస్తున్నప్పుడు లేదా నేను అయోమయం చెపుతున్నానని చెప్తాను మరియు అస్పష్టత ఉందని మరియు అలాంటి సందర్భాలలో, మీరు వేరొక ఫంక్షన్ ఓవర్లోడింగ్ పని చేయడానికి లేదా ఫంక్షన్ ఓవర్లోడింగ్ నివారించడానికి మరియు వేరొక రూపంలో కోడ్ రాయడానికి.
ఓవర్లోడింగ్ అనేది ఒక రూపంలో మీకు స్టాటిక్ పాలిమార్ఫిజం( static polymorphism) ఇస్తుంది.
మేము వెంటనే స్టాటిక్ పాలిమార్ఫిజం యొక్క తీవ్రస్థాయిలోకి వెళ్ళడం లేదు.
వివిధ పూర్ణ C ++ లక్షణాల సందర్భంలో పాలిమార్ఫిజం గురించి మాట్లాడతాము.
ఇక్కడ కోర్ లక్షణాలు నేను రెండు పదాలను వివరించాలనుకుంటున్నాను.
పాలిమార్ఫిజం అర్థం, పాలీ అంటే- అనేక మరియు మార్ఫ్ అంటే- మార్చడానికి.
సో, పాలిమార్ఫిజం బహుళ మార్పులను లేదా బహుళ రూపాలను ఒకటిగా చేస్తోంది.
కాబట్టి, ఇక్కడ పాలిమార్ఫిజం అనగా పేరుతో అదే ఫంక్షన్ అంటే, పారామితి రకం, వేర్వేరు ప్రవర్తన, వివిధ అల్గోరిథంలు( algorithms) మరియు వివిధ ఇంటర్ఫేస్ల మీద ఆధారపడి ఉంటుంది.
కాబట్టి, మీరు ప్రాథమికంగా ఈ బహుళ రూపంపై నిర్ణయిస్తారు మరియు మీరు ఈ స్థిరమైనదని చెప్తారు.
ఏ స్టాటిక్ ఇక్కడ మీరు అన్ని కంపైలర్ సమయం లో చేయాలనుకుంటున్నారని అంటే ఈ కంపైలర్ ఈ బహుళ రూపాల మధ్య నిర్ణయించుకోవాలి మరియు ఈ ఫంక్షన్ కాల్ వద్ద మీరు ఉపయోగించడానికి ప్రయత్నిస్తున్న వేర్వేరు రూపాలు, పాలిమార్ఫిక్ రూపాల్లో ఏది ఖచ్చితంగా చెప్పగలరా.
కాబట్టి, ఈ రకమైన నిర్ణయం లేదా ఓవర్లోడ్ మెకానిజంను కలిపి స్టాటిక్ పాలిమార్ఫిజం అని పిలుస్తారు.
వాస్తవానికి, ఇతర రకాల పాలిమార్ఫిజం కూడా సాధారణంగా డైనమిక్ లేదా రన్ పాలిమార్ఫిజం అని పిలువబడుతున్నాయి, మేము C ++ భాషలోని ఆబ్జెక్ట్( object) బేస్ భాగం గురించి చర్చిస్తున్నప్పుడు చర్చించబోతున్నాం.