[Powered by Google Translate] [CS50 లైబ్రరీ]
[నేట్ Hardison] [హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది. CS50.TV]
CS50 లైబ్రరీ మేము ఉపకరణం ఇన్స్టాల్ చేసిన ఒక ఉపయోగపడిందా సాధనం
మీరు ప్రోగ్రాములను వ్రాయటానికి ఇది సులభం ఆ ఇన్పుట్ కోసం వేచి వినియోగదారులు.
ఈ వీడియో లో, మేము పరదా పుల్ బాక్ చేస్తాము మరియు CS50 లైబ్రరీలో సరిగ్గా ఏమిటి చూడండి.
>> సి లైబ్రరీల మీద వీడియో, మేము మీరు # శీర్షికలు ఫైల్స్ గురించి మాట్లాడటం
మీ సోర్స్ కోడ్ లైబ్రరీ యొక్క,
మరియు మీరు లింక్ దశలో ఒక బైనరీ లైబ్రరీ ఫైల్ తో లింక్
సంగ్రహం ప్రక్రియ యొక్క.
శీర్షిక ఫైళ్లు లైబ్రరీ యొక్క ఇంటర్ఫేస్ తెలుపుము.
అంటే, అవి వివరాలు మీరు ఉపయోగించడానికి లైబ్రరీ అందుబాటులో కలిగి వనరులు అన్ని ఉంటుంది
ఫంక్షన్ ప్రకటనలు, స్థిరాంకాలు మరియు డేటా రకాల ఇష్టపడుతున్నారు.
బైనరీ లైబ్రరీ ఫైలు, లైబ్రరీ అమలు కలిగి
ఇది గ్రంధాలయ శీర్షిక ఫైళ్లు మరియు లైబ్రరీ. సి సోర్స్ కోడ్ ఫైళ్ళనుండి సంగ్రహించబడింది.
>> బైనరీ లైబ్రరీ ఫైలు అది బైనరీ లో, సరే, ఎందుకంటే కు చాలా ఆసక్తికరమైన కాదు.
కాబట్టి, యొక్క శీర్షిక లైబ్రరీ కోసం ఫైళ్ళను బదులుగా పరిశీలించి అనుమతిస్తుంది.
ఈ సందర్భంలో, cs50.h. అని మాత్రమే ఒక శీర్షికా ఫైలును లేదు
మేము వినియోగదారు దానిని ఇన్ స్టాల్ చేసిన డైరెక్టరీ ఉన్నాయి
ఇతర వ్యవస్థ లైబ్రరీలకు 'శీర్షిక ఫైళ్లు పాటు.
>> మీరు గమనిస్తారు మొదటి విషయాలు ఒకటి cs50.h # ఇతర లైబ్రరీలు శీర్షిక ఫైళ్లు కలిగి ఉండటం -
ఫ్లోట్, పరిమితులు, ప్రామాణిక bool, మరియు ప్రామాణిక lib.
మళ్లీ, వీల్ పునరుద్ధరించుకుంటూ లేదు సూత్రాన్ని అనుసరించి
మేము ఇతర మాకు అందించిన ఉపకరణాలు ఉపయోగించి CS0 లైబ్రరీ సృషించిన.
>> మీరు లైబ్రరీలో చూస్తారు తదుపరి విషయం మేము అనే కొత్త రకం నిర్వచించే ఉంది "స్ట్రింగ్."
ఈ లైన్ నిజంగా కేవలం చార్ * రకం కోసం ఒక అలియాస్ సృష్టిస్తుంది
కాబట్టి అది అద్భుతంగా గుణ కొత్త స్ట్రింగ్ రకం రూపొందించే ప్రయత్నం చేస్తారు లేదు
సాధారణంగా, ఇతర భాషలలో స్ట్రింగ్ వస్తువులు సంబంధం
అటువంటి పొడవు.
మేము ఇది చేసిన కారణం నెత్తురు వివరాలను కొత్త ప్రోగ్రామర్లు కవచం ఉంటుంది
గమనికలు యొక్క వారు సిద్ధంగా వరకు.
>> శీర్షికా ఫైలును తదుపరి భాగం విధులను ప్రకటన
CS50 లైబ్రరీ డాక్యుమెంటేషన్ పాటు అందించే.
ఇక్కడ వ్యాఖ్యలు వివరాల స్థాయి గమనించండి.
ప్రజలు ఈ విధులను ఎలా ఉపయోగించాలో తెలిసిన ఈ ముఖ్యమైన సూపర్ ఉంది.
మేము ప్రతిగా, డిక్లేర్, వినియోగదారు మరియు తిరిగి అక్షరాలు, డబుల్స్, తేలుతుంది, ints, ఫలితానికి పని
దీర్ఘ longs, మరియు తీగలను, మా స్వంత స్ట్రింగ్ రకం ఉపయోగించి.
సమాచారం అజ్ఞాతంలోకి సూత్రాన్ని అనుసరించి,
. మేము ప్రత్యేక సి అమలు ఫైలులో మా నిర్వచనం చేసి - cs50.c -
యూజర్ మూల డైరెక్టరీ లో ఉన్న.
మీరు పరిశీలించి తద్వారా మేము, ఆ ఫైల్ అందించిన
అది నేర్చుకోవడం మరియు మీరు అనుకుంటే వివిధ కంప్యూటర్లలో అది మళ్ళీ కంపైల్ చెయ్యండి,
మేము ఈ తరగతి ఉపకరణంపై పని బాగా అని కూడా.
ఏమైనా, ప్రస్తుతం అది పరిశీలించి అనుమతిస్తుంది.
>> విధులు GetChar, GetDouble, GetFloat, GetInt, మరియు GetLongLong
అన్ని GetString ఫంక్షన్ పైన నిర్మించబడ్డాయి.
వారు అవన్నీ ఒకే పద్ధతిని అనుసరించి ఆ అవుతుంది.
ఇవి ఇన్పుట్ యొక్క ఒక లైన్ కోసం వినియోగదారును ప్రాంప్ట్ కొంత లూప్ ఉపయోగించండి.
వినియోగదారు ఇన్పుట్లను ఒక ఖాళీ పంక్తి ఒక ప్రత్యేక విలువ తిరిగి.
వారు సరైన పద్ధతి యూజర్ యొక్క ఇన్పుట్ అన్వయించడం ప్రయత్నం
అది ఒక చార్, డబుల్, ఫ్లోట్, మొదలైనవి ఉండవచ్చును
ఇన్పుట్ విజయవంతంగా అన్వయించడం ఒకవేళ వారు గాని ఫలితం తిరిగి
లేదా యూజర్ reprompt.
>> అధిక స్థాయిలో, నిజంగా గమ్మత్తైన ఏమీ ఇక్కడ ఉంది.
మీరు గతంలో అదేవిధంగా నిర్మాణాత్మక కోడ్ మీరే రాసిన ఉండవచ్చు.
బహుశా చాలా గుప్తమైన కనిపించే భాగం యూజర్ యొక్క ఇన్పుట్ కావలసిన విధంగా విభజిస్తుంది ఆ sscanf పిలుపు.
Sscanf ఇన్పుట్ ఫార్మాట్ మార్పిడి కుటుంబం యొక్క భాగం.
, ఇది ప్రామాణిక io.h నివసిస్తున్నారు, మరియు దాని పని ఒక సి స్ట్రింగ్ అన్వయించడానికి
వేరియబుల్ అన్వయ ఫలితాలు నిల్వ, ఒక నిర్దిష్ట ఫార్మాట్ ప్రకారం
కాలర్ అందించిన.
ఇన్పుట్ ఫార్మాట్ మార్పిడి ఫంక్షన్లను చాలా ఉపయోగకరంగా, విస్తృతంగా ఉపయోగించే క్రియలు నుండి
, మొదటి వద్ద స్పష్టమైన సూపర్ లేని
మేము sscanf ఎలా పనిచేస్తుంది వెళ్ళి చేస్తాము.
>> sscanf మొదటి వాదన ఒక చార్ * - ఒక పాత్ర ఒక పాయింటర్.
విధి సరిగ్గా పని, కోసం
ఆ పాత్ర, C స్ట్రింగ్ మొదటి అక్షరం ఉండాలి
శూన్య \ 0 పాత్ర రద్దు.
ఈ అన్వయించడం స్ట్రింగ్
sscanf రెండో వాదన, ఒక ఫార్మాట్ స్ట్రింగ్
సాధారణంగా, ఒక స్ట్రింగ్ స్థిరంగా వంటి జారీ
మరియు మీరు printf ఉపయోగించేటప్పుడు ముందు ఈ వంటి స్ట్రింగ్ మందికి తెలిసి ఉంటుంది.
ఫార్మాట్ స్ట్రింగ్ ఒక శాతం సైన్ ఒక మార్పిడి స్పెసిఫయ్యర్ సూచిస్తుంది.
పాత్ర వెంటనే, ఒక శాతం సైన్ తరువాత
మేము మార్చుకునేందుకు sscanf కావలసిన సి రకం సూచిస్తుంది.
GetInt, మీరు ఒక% d మరియు ఒక% సి ఉందని చూడండి.
% D - - మరియు ఒక చార్ -% సి ఈ sscanf ఒక దశాంశ పూర్ణాంకానికి ప్రయత్నించండి చేస్తాము.
ఫార్మాట్ స్ట్రింగ్ ప్రతి మార్పిడి స్పెసిఫయ్యర్ కోసం,
sscanf దాని వాదన జాబితాలో సంబంధిత వాదన తరువాత ఆశించారు.
ఆ వాదన ఒక సరిగ్గా టైప్ చేసిన నగర స్థానాన్ని సూచిస్తుంది ఉండాలి
మార్పిడి యొక్క ఫలితంగా నిల్వ దీనిలో.
>> ఇలా విలక్షణ మార్గం sscanf కాల్ ముందు స్టాక్ ఒక వేరియబుల్ సృష్టించడానికి ఉంది
మీరు స్ట్రింగ్ నుండి విశ్లేషించడం చేయదలిచిన ప్రతి అంశం కోసం
గమనికలు పాస్ - ఆంపర్సండ్ చిహ్నం - మరియు తర్వాత చిరునామా ఆపరేటర్లు ఉపయోగించడానికి
sscanf కాల్ ఆ చరరాశులకు.
మీరు GetInt లో మేము ఖచ్చితంగా ఈ విషయాలను చూడగలరు.
కుడి sscanf కాల్ ముందు, మేము, n అనే ఒక Int మరియు స్టాక్ ఒక చార్ కాల్ సి డిక్లేర్
మరియు మేము sscanf కాల్ వాటిని కు గమనికలు పాస్.
స్టాక్ ఈ చరరాశులు పుటింగ్ కేటాయించింది స్థలం ఉపయోగించి ఎక్కువ ప్రాధాన్యత ఉంది
మీరు malloc కాల్ యొక్క భారాన్ని నివారించటానికి నుండి malloc తో కుప్ప, న,
మరియు మీరు మెమరీ లీకింగ్ గురించి ఆందోళన లేదు.
ఒక శాతం సైన్ ద్వారా ముందు కాదు అక్షరాలు మార్పిడి ప్రాంప్ట్ లేదు.
వారు కేవలం ఫార్మాట్ వివరణ జోడించండి.
>> ఉదాహరణకు, GetInt లో ఫార్మాట్ స్ట్రింగ్ బదులుగా% d ఉంటే,
sscanf, ఒక పూర్ణాంకానికి తర్వాత ఒక లేఖ కొరకు చూస్తారు
అది Int మార్చేందుకు ప్రయత్నిస్తామని, ఇది ఒక తో ఇంకా ఏమి లేదు.
ఈ మాత్రమే మినహాయింపు తెల్లని ఉంది.
ఫార్మాట్ స్ట్రింగ్ లో వైట్ స్పేస్ అక్షరాలు తెల్లని ఏ మొత్తం మ్యాచ్ -
అన్ని వద్ద కూడా ఏదీ లేదు.
వ్యాఖ్య ప్రముఖ మరియు / లేదా తెల్లని ప్రకారం బహుశా పేర్కొన్నాడు వై సో, ఆ.
కాబట్టి, అది మా sscanf కాల్ కనిపిస్తోంది ఈ సమయంలో యూజర్ యొక్క ఇన్పుట్ స్ట్రింగ్ అన్వయించడం ప్రయత్నించండి
సాధ్యం ప్రముఖ తెల్లని కోసం తనిఖీ చెయ్యడం ద్వారా,
Int వేరియబుల్ n మతం మరియు నిల్వ చేయబడుతుంది ఒక Int తరువాత
తెల్లని కొన్ని మొత్తం తరువాత, మరియు ఒక పాత్ర తర్వాత
చార్ వేరియబుల్ సి నిల్వ.
>> తిరిగి విలువ గురించి ఏమిటి?
Sscanf, పూర్తి మొదటి నుంచి ఇన్పుట్ పంక్తిని అన్వయించడం కనిపిస్తుంది
ఇన్పుట్ ఒక పాత్ర అది అంతిమ చేరుకున్నప్పుడు ఆపటం లేదా
ఒక ఫార్మాట్ పాత్ర సరిపోలడం లేదు లేదా అది మార్పిడి చేయలేరు ఉన్నప్పుడు.
ఇది తిరిగి విలువ నిలిపివేశారు ఉన్నప్పుడు ఒకే ఉపయోగిస్తారు.
ఇది ఇన్పుట్ స్ట్రింగ్ చివరికి చేరుకున్నాక ఎందుకంటే, ఆగిపోయింది ఉంటే
ఏ మార్పిడులు ముందు మరియు ఫార్మాట్ స్ట్రింగ్ భాగంగా మ్యాచ్ విఫలమవడానికి ముందుగా,
తరువాత ప్రత్యేక స్థిరంగా EOF తిరిగి.
లేకపోతే, అది, విజయవంతమైన మార్పిడిల సంఖ్య తిరిగి
మేము రెండు మార్పిడుల కోసం అడిగారు నుండి ఇది, 0, 1, లేదా 2 ఉంటుంది.
మా సందర్భంలో, మేము వినియోగదారు ఒక Int మరియు మాత్రమే ఒక Int లో టైప్ చేసి నిర్ధారించుకోవాలి.
>> కాబట్టి, మేము sscanf 1 తిరిగి అనుకుంటున్నారా. ఎందుకు?
Sscanf 0 తిరిగి, అప్పుడు ఏ మార్పిడులు జరిగాయి,
కాబట్టి యూజర్ ఇన్ పుట్ ప్రారంభంలో ఒక పూర్ణాంకానికి కంటే ఇతర ఏదైనా టైప్.
Sscanf 2 తిరిగి ఉంటే, తరువాత వినియోగదారు సరిగా ఇన్పుట్ ప్రారంభంలో అది టైప్ చేశారా
కానీ వారు అప్పుడు తర్వాత కొన్ని కాని తెల్లని పాత్ర లో టైప్
% నుండి సి మార్పిడి విజయవంతమయ్యింది.
వావ్, అది చాలా ఒక ఫంక్షన్ కాల్ కొరకు సుదీర్ఘ వివరణ ఉంది.
ఏమైనా, మీరు sscanf మరియు దాని తోబుట్టువుల మరింత సమాచారం కావాలంటే,
man పేజీలను, Google, లేదా రెండూ చూడండి.
ఫార్మాట్ స్ట్రింగ్ ఐచ్చికాలను మా ఉన్నాయి
C. లో తీగలను అన్వయించడం ప్రయత్నిస్తున్నప్పుడు మరియు ఈ మీరు శారీరక శ్రమ చాలా సేవ్ చేయవచ్చు
>> కు లైబ్రరీలో చివరి చర్యను GetString ఉంది.
ఇది GetString సరిగా రాయడానికి ఒక గమ్మత్తైన విధి అని అవుతుంది
ఇది సరళమైన, సాధారణ పని వంటి తెలుస్తోంది అయినప్పటికీ.
ఎందుకు ఈ సందర్భంలో?
సరే, ఎలా మేము లైన్ నిల్వ చూడాలని గురించి ఆలోచించటం అనుమతించే సైన్ యూజర్ రకాల
ఒక స్ట్రింగ్ అక్షరాలు ఒక వరుస క్రమం నుంచి
మేము, స్టాక్ న వ్యూహంలో ఇది నిల్వ చేయవచ్చు
కానీ మనం దాని డిక్లేర్ చేసినప్పుడు అర్రే అయి అన్నారు ఎంత తెలుసు వుంటుంది.
అలాగే, మేము కుప్ప ఉంచారు అనుకుంటే,
మేము, malloc మేము రిజర్వ్ మీరు బైట్లు సంఖ్య పాస్ అవసరం
కానీ ఈ అసాధ్యం.
మేము వినియోగదారు టైప్ ఎలా అనేక అక్షరాలు సంఖ్య ఆలోచన ఉంది
యూజర్ వాస్తవానికి టైప్ లేదు ముందు.
>> ఈ సమస్యకు ఒక పరిష్కారం సరళ కేవలం, స్పేస్ పెద్ద భాగం ప్రత్యేకించబడిందని సే, ఉంది
యూజర్ యొక్క ఇన్పుట్ కోసం 1000 అక్షరాలు ఒక బ్లాక్,
యూజర్ దీర్ఘ ఒక స్ట్రింగ్ లో టైప్ ఎన్నటికీ ఊహించండి.
ఈ రెండు కారణాల కొరకు ఒక మంచి ఆలోచన కాదు.
మొదటి, వినియోగదారులు సాధారణంగా దీర్ఘ తీగలను టైప్ లేని ఊహించండి
మీరు మెమరీ చాలా వృధా కాలేదు.
మీరు ఇలా చేస్తే ఆధునిక యంత్రాల్లో, ఈ సమస్య కాదు
ఒకటి లేదా రెండు ఒంటరి సందర్భాల్లో,
కానీ మీరు ఒక లూప్ వినియోగదారు యొక్క ఇన్పుట్ తీసుకుని తదుపరి ఉపయోగానికి నిల్వ చేస్తుంటే,
మీరు త్వరగా మెమరీ ఒక టన్ను పీల్చడానికి చేయవచ్చు.
అదనంగా, మీరు రాస్తున్నాం కార్యక్రమం చిన్న కంప్యూటర్ కోసం -
పరిమిత మెమరీ ఒక స్మార్ట్ఫోన్ లేదా ఏదో వంటి పరికరము -
ఈ పరిష్కారం చాలా వేగంగా సమస్య వస్తుందని.
ఈ కాక రెండవ, తీవ్రమైన కారణం ఇది హానికరంగా మీ ప్రోగ్రామ్ బయటకు ఉంది
ఒక బఫర్ ఓవర్ఫ్లో దాడి అని పేర్కొంది.
ప్రోగ్రామింగ్ లో, ఒక బఫర్, తాత్కాలికంగా ఇన్పుట్ లేదా అవుట్పుట్ సమాచారాన్ని నిల్వ చేయడానికి ఉపయోగించే మెమరీ
ఈ సందర్భంలో మా 1000 చార్ బ్లాక్ ఇది.
డేటా బ్లాక్ ముగింపులో గత వ్రాసిన ఒక బఫర్ ఓవర్ఫ్లో జరుగుతుంది.
>> ఉదాహరణకు, ఒక వినియోగదారు నిజానికి 1000 కంటే ఎక్కువ అక్షరాలు టైప్ ఒకవేళ.
శ్రేణితో ప్రోగ్రామింగ్ మీరు అనుకోకుండా ఈ ఎదుర్కొని ఉండవచ్చు.
మీరు 10 ints యొక్క వ్యూహం ఉంటే, ఏమీ చదవండి లేదా వ్రాయడానికి ప్రయత్నించడంలో నుండి మీరు ఆపి
15 Int.
ఏ కంపైలర్ హెచ్చరికలు లేదా లోపాలు ఉన్నాయి.
కార్యక్రమం కేవలం నేరుగా ముందుకు బ్లన్డర్స్ మరియు మెమరీ యాక్సెస్
అది భావించిన పేరు 15 వ Int ఉంటుంది, మరియు ఇది మీ ఇతర అంశాలపై తిరిగి రాస్తుంది చేయవచ్చు.
చెత్త సందర్భంలో, మీ ప్రోగ్రామ్ యొక్క అంతర్గత కొన్ని తిరిగి రాస్తుంది చేయవచ్చు
నియంత్రణ వ్యవస్థ, మీ ప్రోగ్రామ్ దీనివల్ల వాస్తవానికి వివిధ సూచనలను అమలు
మీరు ఉద్దేశించిన కంటే.
>> ఇప్పుడు,, అనుకోకుండా దీన్ని సాధారణ కాదు
కానీ ఈ చెడ్డ అబ్బాయిలు కార్యక్రమాలు తొలగించేందుకు ఉపయోగించే ఒక సాధారణ టెక్నిక్
మరియు ఇతర వ్యక్తుల కంప్యూటర్లలో హానికరమైన కోడ్ను ఉంచాలి.
కాబట్టి, మేము మా అమాయక పరిష్కారం ఉపయోగించలేరు.
మేము అవకాశం నుండి మా కార్యక్రమాలు నివారించడానికి మార్గాన్ని అవసరం
ఒక బఫర్ ఓవర్ఫ్లో దాడి.
ఇది చేయుటకు, మేము చదవడానికి మా బఫర్ పెరిగే నిర్ధారించుకోవాలనుకుంటున్నాము
వినియోగదారు నుండి మరింత ఇన్పుట్.
పరిష్కారం? మేము ఒక నిండుగా కేటాయించింది బఫర్ ఉపయోగించండి.
మేము పరిమాణాన్ని చెయ్యవచ్చు కనుక ఇది పునఃపరిమాణం realloc ఫంక్షన్ను ఉపయోగించి
మరియు మేము రెండు సంఖ్యల ట్రాక్ - తరువాతి ఖాళీ స్లాట్ సూచిక బఫర్ లో
మరియు పొడవు లేదా బఫర్ యొక్క సామర్థ్యం.
మేము fgetc ఫంక్షన్ను ఉపయోగించి ఒక సమయంలో వినియోగదారు నుండి అక్షరాలు లో చదవండి.
stdin - - fgetc ఫంక్షన్ పడుతుంది వాదన, ప్రామాణిక ఇన్పుట్ స్ట్రింగ్ ను సూచిస్తుంది
ఇది వినియోగదారు యొక్క ఇన్పుట్ బదిలీ చేయడానికి ఉపయోగిస్తారు ఒక preconnected ఇన్పుట్ ఛానల్
టెర్మినల్ నుండి కార్యక్రమానికి.
>> ప్రతిసారి కొత్త పాత్ర లో యూజర్ రకాల మేము చూడటానికి తనిఖీ ఉంటే సూచిక
తదుపరి ఉచిత స్లాట్ ప్లస్ 1 బఫర్ యొక్క సామర్థ్యం కంటే ఎక్కువగా ఉంటుంది.
+1, తదుపరి ఉచిత ఇండెక్స్ 5 ఉంటే ఎందుకంటే వస్తుంది
అప్పుడు మా బఫర్ యొక్క పొడవు 6 ధన్యవాదాలు 0 ఇండెక్సింగ్ ఉంటుంది.
మేము బఫర్ లో ఖాళీ ఉంటే, మేము, దాని పరిమాణాన్ని ప్రయత్నం
మేము పరిమాణాన్ని సమయాన్ని తగ్గించుకుంటారు తద్వారా అది రెట్టింపు
యూజర్ ఒక నిజంగా దీర్ఘ స్ట్రింగ్ లో టైప్ చేస్తే.
స్ట్రింగ్ చాలా పొడవుగా సంపాదించిన చేసింది లేదా మేము కుప్ప మెమరీ అమలు చేస్తే ఉంటే,
మేము మా బఫర్ మరియు తిరిగి శూన్య ఉచితం.
>> చివరగా, మేము స్వీకరించేందుకు చార్ కలపవచ్చు.
యూజర్ హిట్స్ ఎంటర్ లేదా తిరిగి, ఒక కొత్త లైన్ సిగ్నలింగ్, ఒకసారి
లేదా ప్రత్యేక చార్ - నియంత్రణ d - ఇన్పుట్ సిగ్నల్స్ యాన్ ఎండ్ ఇది,
మేము వినియోగదారు నిజానికి వద్ద ఏదైనా టైప్ ఉంటే చూడటానికి చెక్ చేయండి.
లేకపోతే, మేము శూన్య తిరిగి.
లేకపోతే, మా బఫర్ మేము అవసరం కంటే బహుశా ఎక్కువగా ఉంటుంది,
విషయంలో అది మేము అవసరం దాదాపు రెట్టింపు పెద్దదిగా ఉంది
మేము పరిమాణాన్ని ప్రతిసారీ రెట్టింపు, నుండి
మేము అవసరమైన స్థలం కేవలం మొత్తం ఉపయోగించి స్ట్రింగ్ యొక్క రూపొందిస్తుంది.
మేము, malloc కాల్ ఒక అదనపు 1 జోడించండి
\ 0 - ప్రత్యేక శూన్య టెర్మినేటర్ పాత్ర కోసం స్థలం, అందుచే
ఇది మేము అక్షరాలు మిగిలిన కాపీ ఒకసారి మేము స్ట్రింగ్ కు జోడించు,
బదులుగా strcpy యొక్క strncpy ఉపయోగించి
కాబట్టి మనం కాపీ ఖచ్చితంగా ఎన్ని అక్షరాలు పేర్కొనవచ్చు.
అది ఒక \ 0 హిట్స్ వరకు Strcpy కాపీ చేస్తుంది.
అప్పుడు మేము మా బఫర్ ఉచిత కాలర్ కాపీ తిరిగి.
>> ఇంత సరళమైన-ప్రేరక కారకాలుగా కనిపించేవాటిని ఫంక్షన్ కాబట్టి క్లిష్టమైనది తెలుసు?
ఇప్పుడు మీరు CS50 లైబ్రరీ లోకి వెళ్ళిపోతుంది తెలుసు.
>> నా పేరు నేట్ Hardison, మరియు ఈ CS50 ఉంది.
[CS50.TV]