[సంగీతాన్ని]
>> డేవిడ్ J. మలన్: అన్ని కుడి, ఈ CS50 ఉంది.
మరియు ఈ వారం ఒకటి.
సో వారం సున్నా లో చివరిసారి గుర్తుకు, మనం గణన ఆలోచన దృష్టి సారించింది.
మరియు మేము నుండి బదిలీ స్క్రాచ్, గ్రాఫికల్ ప్రోగ్రామింగ్
మా ఫ్రెండ్స్ నుండి భాషను MIT యొక్క మీడియా ల్యాబ్ వద్ద.
>> మరియు స్క్రాచ్ తో, మేము అన్వేషించండి లేదు విధులు వంటి ఆలోచనలు, మరియు పరిస్థితులు,
మరియు ఉచ్చులు, మరియు వేరియబుల్స్ మరియు కూడా ఈవెంట్స్, మరియు దారాలను, మరియు మరింత.
నేడు, మేము చేయబోతున్నామని ఆ ఆలోచనలు ఉపయోగించడం కొనసాగించాలని,
మరియు నిజంగా వాటిని తీసుకొని మంజూరు, కానీ వాటిని అనువదిస్తుంది
సి ఇప్పుడు అని పిలుస్తారు మరో భాషకు, సి మరింత సంప్రదాయ భాష.
ఇది తక్కువ స్థాయి భాష, మీరు రెడీ ఉంటే.
>> ఇది పూర్తిగా పాఠ్య వార్తలు.
అందువలన మొదటి చూపులో, అంతే అన్ని కాకుండా చూడండి కానుంది గుప్తమైన
మీరు ముందు ప్రోగ్రామ్ ఎప్పుడూ ఉంటే.
మేము చూడాలని సెమీ కోలన్, మరియు బ్రాకెట్లు
మరియు గిరజాల జంట కలుపులు, మరియు మరింత.
కానీ ఆ కూడా ఇవ్వరు వాక్యనిర్మాణం అయితే
ఒక చిన్న తెలియని చూడాలని గురించి మీలో చాలామందికి, ఆ గత చూడండి.
మరియు ఆలోచనలు చూడటానికి ప్రయత్నించండి ఆ ఉంటాయి, నిజానికి, తెలిసిన,
ఎందుకంటే ఇక్కడ వారంలో ఒకటి ఏమి మేము ఏమి పోల్చడానికి ఉంది చేస్తాము
ప్రారంభంలో, వర్సెస్ సి స్క్రాచ్
>> కాబట్టి, ఉదాహరణకు, రీకాల్ మేము ఆ మా కార్యక్రమాలు మొదటి అమలు
చివరిసారి, మేము కనిపిస్తున్న ఒక స్టాప్ కలిగి దీన్ని ఉన్నప్పుడు వంటి కొంత
ఆకుపచ్చ జెండా క్లిక్, ఆపై మేము కలిగి ఇది క్రింది ఒకటి లేదా ఎక్కువ పజిల్ ముక్కలు,
ఈ సందర్భంలో, సే హలో.
అందువలన, నిజానికి, స్క్రాచ్ లో, నేను ఆ ఆకుపచ్చ జెండా క్లిక్ చేసినప్పుడు
నా ప్రోగ్రామ్ను అమలు చేయడానికి కాబట్టి, , మాట్లాడటం ఇవి
రన్ అమలు బ్లాక్స్, లేదా.
మరియు, ప్రత్యేకంగా, స్క్రాచ్ , హలో, ప్రపంచం చెప్పారు.
>> ఇప్పుడు, నేను పేర్కొన్న ఉండవచ్చు ఇక్కడ వివిధ పదాలు.
కానీ మేము నిజానికి, ఆ, అనేక చూస్తారు ఈ blocks-- మరియు నిజానికి యొక్క,
సి అనేక విధులను ఉంటుంది పారామితీకరణ లేదా అనుకూలీకరించిన
వివిధ పనులను.
నిజానికి, మేము ఉంటే సి లో ఇప్పుడు మార్చాలనుకుంటున్నాను,
ఈ స్క్రాచ్ కార్యక్రమం ఈ ఇతర భాష,
మేము ఒక రాయాలో ఈ వంటి చిన్న ఏదో.
>> మంజూరు, అక్కడ కొన్ని తెలియని అక్కడ వాక్యనిర్మాణం ఎక్కువగా, Int,
మరియు బ్రాకెట్లు మరియు శూన్యమైన.
కానీ మీరు చేస్తాను అయినప్పటికీ printf-- అది కేవలం ముద్రణ ఉంటుందనుకుంటున్నాను.
కానీ ముద్రణ ముద్రణ అర్థం మేము వెంటనే చూస్తారు వంటి, ఫార్మాట్.
ఈ అక్షరాలా ముద్రిస్తుంది తెరకు సంసార
ఆ కుండలీకరణాలు లోపల ఇది కోర్సు యొక్క ఈ సందర్భంలో, హలో ప్రపంచ.
>> కానీ మీరు కొన్ని ఇతర గమనిస్తారు వాక్యనిర్మాణం, కొన్ని డబుల్ కోట్స్,
చివర భాగాన బ్రాకెట్లు సెమీ కోలన్ మరియు వంటి.
కాబట్టి భారాన్ని ఒక బిట్ ఉంది మాట్లాడటానికి, రెండు అభిజ్ఞాత్మకంగా
మరియు పదము, మేము వెళ్లి చేస్తున్న దీర్ఘ ముందు గుర్తుంచుకోవడానికి కలిగి.
కానీ, ఆచరణలో తో అని తెలుసుకోవటం ఈ మీరు వద్ద జంప్ అవుట్ ప్రారంభమౌతుంది.
>> నిజానికి, యొక్క ఒక దృష్టి వీలు ఫంక్షన్ ఈ సందర్భంలో specifically--,
హలో ప్రపంచ చెప్పటానికి.
కాబట్టి ఫంక్షన్ అని చెబుతారు.
హలో, ప్రపంచం దాని పరామితి, లేదా వాదన దాని అనుకూలీకరణకు.
>> మరియు C సమాన కేవలం ఇక్కడ ఈ ఒక చేస్తాడు లైన్,
printf కు సమానం, చెప్పడానికి, డబుల్ కోటెడ్ స్ట్రింగ్, హలో
ప్రపంచ కోర్సు యొక్క, సమానం, అక్కడ తెల్లని బాక్స్ లో ఏది.
మరియు బాక్ స్లాష్ n, కొద్దిగా అయితే వింత మరియు స్క్రాచ్ నుండి తప్పుకున్నాడు,
కేవలం మేము చేస్తాము చూపుతోందని అన్నారు ఒక కంప్యూటర్ లో చూడటానికి, నా Mac లేదా PC వంటి,
కేవలం కదిలే తదుపరి లైన్ కర్సర్ను.
కొట్టినట్లయితే వంటిది మీ కీబోర్డ్ లో నమోదు చేయండి.
>> కాబట్టి మేము దీర్ఘ ముందు మళ్ళీ చూస్తారు.
కానీ మొదటి, యొక్క ఈ పరిశీలించి వీలు ఉచ్చులు విషయంలో మరొక ఉదాహరణ.
మేము చివరిసారి ఎప్పటికీ లూప్ కలిగి, ఇది పజిల్ ముక్కలు వరుస
అక్షరాలా ఏదో చేశారు ఈ సందర్భంలో forever--,
చెప్పటానికి హలో ప్రపంచ, హలో వరల్డ్ హలో వరల్డ్, హలో వరల్డ్.
కనుక ఇది డిజైన్ ద్వారా ఒక అనంతమైన లూప్.
>> సి లో, మేము ఈ అమలు అనుకుంటే అదే ఆలోచన, మేము కేవలం దీన్ని ఉండవచ్చు.
నిజమైన అయితే, హలో printf ఇప్పుడు world-- అయితే, కేవలం అర్థ రకమైన
చేయడం ఆలోచన అప్ చూపిస్తుంది మళ్ళీ ఏదో, మళ్ళీ, మళ్ళీ,
మరియు ఎంత కోసం?
బాగా, true-- గుర్తుకు నిజమైన కేవలం ఆన్ లేదా ఒకటి.
>> మరియు నిజమైన, కోర్సు యొక్క, ఎల్లప్పుడూ నిజం.
కనుక ఇది ఒక అర్ధం రకంగా ప్రకటన కేవలం నిజమైన చెప్పటానికి.
కానీ నిజానికి, ఈ ఉద్దేశపూర్వక ఉంది, నిజమైన కేవలం ఎప్పుడూ నిజం,
నిజమైన కేవలం సూచిస్తుంది ఉన్నప్పుడు కంటే, పరోక్షంగా కొద్దిగా ఉంటే,
కోడ్ క్రింది పంక్తులు ఆ ఆ వంకర జంట కలుపులు మధ్య
కేవలం మళ్ళీ, మళ్ళీ అమలు చేయాలి, మళ్ళీ, నిజానికి ఆపడానికి ఎప్పుడూ.
>> కానీ మీరు అనుకుంటే మీ గా మేము, ఆపడానికి లూప్
అలాంటిదే చివరిసారి ఈ క్రింది 50 సార్లు పునరావృతం,
సి లో మేము ఏమి తో కలగొచ్చు కీవర్డ్ లూప్ ఒక అని
కాదన్న కానీ చేస్తున్నప్పుడు.
మరియు తర్వాత మేము ఇక్కడ కొన్ని కొత్త సింటాక్స్, Int తో నేను, 0 సమానం నేను 50 కంటే తక్కువ,
నేను ++.
మరియు మేము ఆ వచ్చి చేస్తాము.
కానీ ఈ కేవలం ఎంత మనం స్క్రాచ్ బ్లాక్స్ సెట్ అనువదించడానికి
కోడ్ యొక్క సి పంక్తులు ఒక సెట్ను.
>> ఇంతలో, వేరియబుల్స్ భావిస్తారు.
మరియు, నిజానికి, మేము కేవలం ఒక క్షణం క్రితం చూసింది.
మరియు స్క్రాచ్ విషయంలో, మనం ఉంటే నేను అనే వేరియబుల్ ప్రకటించాలని కావలెను
పూర్ణాంకం నేను ఉన్నందుకు, కేవలం ఒక సంఖ్య మరియు మేము కొన్ని విలువ దానిని సెట్ అనుకుంటే,
మేము ఈ నారింజ వుపయోగించాలి బ్లాక్ ఇక్కడ నేను 0 సెట్.
>> మరియు మేము ఈ రోజు చూస్తారు మరియు మించి, కేవలం గత వారం వంటి,
ప్రోగ్రామర్లు దాదాపు ఎల్లప్పుడూ చేసే నిజంగా, సున్నా నుండి లెక్కింపు మొదలు
సాంప్రదాయకంగా.
కానీ నుండి రీకాల్ ఎందుకంటే బైనరీ మా చర్చ,
చిన్న సంఖ్య మీరు బిట్స్ ఎన్ని ప్రాతినిధ్యం
కేవలం 0 కూడా అవతరిస్తుంది.
అందువలన మేము సాధారణంగా మొదలు పెడతారేమో 0 కూడా మా వేరియబుల్స్ ప్రారంభించడం.
>> మరియు సి, అదే చేయాలని మేము Int చెప్పడానికి వెళుతున్న
పూర్ణాంక కోసం సాంప్రదాయకంగా, ఐ.
నేను ఈ వేరియబుల్ అని ఉండవచ్చు ఏదైనా నేను కేవలం స్క్రాచ్ లో వంటి, మీరు.
ఆపై 0 కేవలం హక్కుదారులు సమానం విలువ 0 ఎమ్మా నుండి
మరియు అది వేరియబుల్ లోకి ఉంచుతుంది, లేదా అక్కడ నిల్వ కంటైనర్ ఎడమ.
మరియు సెమీ కోలన్ మేము see-- చేస్తాము మరియు మేము ఈ already-- కొన్ని చూసిన
కేవలం ఆలోచన ముగింపు అంటే.
ఏదో వెళ్లండి ఆఫీసు అనుసరించండి న.
>> ఇప్పుడు, ఏమి బూలియన్ వ్యక్తీకరణలు గురించి?
స్క్రాచ్ లో గుర్తుచేసుకున్నారు, ఈ వ్యక్తీకరణలు ఉన్నాయి
గాని నిజం అని లేదా తప్పుడు ప్రశ్నలు,
నిజంగా, నిజమైన లేదా తప్పుడు గాని అని.
కాబట్టి స్క్రాచ్ విషయంలో, మేము వాటిని ఈ వంటి ఒక సాధారణ ప్రశ్న అడగండి
నేను 50 కంటే తక్కువ?
నేను, మళ్ళీ, ఒక పూర్ణ సంఖ్య.
బహుశా మేము దానిని ఉపయోగించి మీరు ఒక స్క్రాచ్ కార్యక్రమంలో
స్కోరుతో ట్రాక్ లేదా అలాంటిదే.
స్క్రాచ్ లో ఇక్కడ ఈ వాక్యనిర్మాణం కాబట్టి కేవలం, అనగా నేను 50 కంటే తక్కువ?
బాగా, అదృష్టవశాత్తూ, ఏదో ఉంది C. లో మరియు అనువదించడానికి సాధారణ,
ఈ మేము కేవలం తక్కువ నేను చెబుతా 50 కంటే తెలిసిన కీని ఉపయోగించి
మీ కీబోర్డ్ లో.
>> ఇంతలో, ఉంటే మీరు కోరుకుంటే ఏదో సాధారణ సే,
బాగా, వంటిది Y పేరు ప్రతి కంటే x తక్కువ x మరియు y యొక్క తాము వేరియబుల్స్ ఉన్నాయి?
మేము అదే విషయం చేయవచ్చు సి లో, చాలా కాలం మేము చేసిన వంటి
ఇప్పటికే ఈ వేరియబుల్ సృష్టించాను.
మరియు మేము చూస్తారు దీర్ఘ ముందు అలా.
మేము కేవలం x, y కంటే తక్కువ చెబుతారు.
>> సో మీరు మొదలు పెడుతున్నారు కొన్ని సారూప్యతలు చూడండి.
మరియు చేసిన వారికి చేసారో స్క్రాచ్ ఖచ్చితంగా ఉన్నాయి
ఈ ప్రాథమిక ఆలోచనలు కొన్ని ప్రేరణ.
మరియు మీరు ఈ రకమైన చూస్తారు అనేక భాషల లో సింటాక్స్
కేవలం, స్క్రాచ్ కాదు కేవలం సి, కానీ పైథాన్,
మరియు JavaScript, మరియు ఇతర భాషలు ఇప్పటికీ.
>> మరో నిర్మాణం పరిగణలోకి లెట్ C నుండి ఒక పరిస్థితి యొక్క భావన,
షరతులతో ఏదో చేయడం.
ఏదో నిజమైన ఉంటే, దీన్ని.
ఏదో నిజమైన ఉంటే, అలా.
ఇది ప్రోగ్రామింగ్ విధమైన వార్తలు రహదారి ఒక ఫోర్క్ సమానం.
దీనికి రెండు మార్గం ఫోర్క్ వార్తలు, మూడు మార్గం fork, లేదా మరింత.
మరియు స్క్రాచ్ లో, మేము కలిగి ఉండవచ్చు ఈ వంటి ఏదో చూసిన.
>> కాబట్టి ఈ ఒక పెద్ద ఒకటి.
కానీ సంబంధిత పరిగణలోకి తర్కం యొక్క సరళత.
x, y కంటే తక్కువ ఉంటే, అప్పుడు x తక్కువ అని చెబుతారు వై కంటే, x, y కంటే ఎక్కువ వేరే ఉంటే,
అప్పుడు x, y కంటే ఎక్కువ అని చెబుతారు.
ఆపై, తార్కికంగా ఉంటే మీరు స్క్రాచ్ తిరిగి భావిస్తే
లేదా మీ స్వంత మానవ అంతర్బుద్ధి కూడా, x, y కంటే ఎక్కువ కాదు ఉంటే, మరియు x
కోర్సు యొక్క అప్పుడు, Y కంటే తక్కువ కాదు x y కు సమానమైనది అని అన్నారు.
కాబట్టి ఈ సందర్భంలో, గూడు ద్వారా ఆ స్క్రాచ్ బ్లాక్స్,
మనం మూడు సాధించింది రోడ్డు మార్గం fork?
>> ఇంతలో, మేము అనుకుంటే నిస్సందేహంగా, C లో దీన్ని
కనీసం ఒక చిన్న simpler-- కనిపిస్తుంది మీరు వాక్యనిర్మాణం తో పరిచయం పొందడానికి ఒకసారి.
x, y కంటే తక్కువ ఉంటే, printf x, y కంటే తక్కువగా ఉంటుంది.
ఎల్స్ x, y కంటే ఎక్కువ ఉంటే, printf x, y కంటే ఎక్కువ.
మిగిలిన printf x Y ఉంటే మరియు సమానంగా ఉంది, మళ్ళీ, తో ఆ బాక్ స్లాష్ కేవలం ముగుస్తుంది
ఆ కొత్త లైన్లు కోసం కాబట్టి మీరు నిజానికి ఈ రకమైన కార్యక్రమం నడిచింది
అది కేవలం కదులుతారు మీ కర్సర్ చివరికి
స్క్రీన్ తదుపరి లైన్.
>> ఇప్పుడు, మరోవైపు స్క్రాచ్ ఇతర కలిగి మరింత అధునాతన ఫీచర్లు మాత్రమే
వీటిలో కొన్ని మేము చేయబోతున్నామని మొదట సి ప్రపంచంలోకి అడుగిడాలని
వారిలో ఒకరు స్క్రాచ్ లో జాబితా అని.
మరియు ఈ ఒక ప్రత్యేక ఉంది వేరియబుల్ రకం
మీరు బహుళ పనులు నిల్వ వీలుకల్పించే అది తిరిగి, తిరిగి, తిరిగి, తిరిగి.
>> సి, అది లేదు జాబితాలు, కేవలంగా, కానీ ఏదో
మరింత సాధారణంగా ఉంటాయి శ్రేణుల మేము చేస్తాము అయితే అని,
తరువాత ఈ సెమిస్టర్ తిరిగి వచ్చి ఏదో చూడటం
జాబితా లేదా నిజంగా ఒక లింక్ జాబితా అని.
కానీ ఇప్పుడు కోసం, సన్నిహిత మాకు సి లో సమానమైన
ఏదో అవతరిస్తుంది వ్యూహం అని.
మరియు ఒక అర్రే కేవలం ఒక ఉంది వేరియబుల్ యొక్క ప్రత్యేక రకం
మీరు డేటా నిల్వ అనుమతిస్తుంది తిరిగి, తిరిగి, తిరిగి, తిరిగి.
>> మరియు, నిజానికి, స్క్రాచ్ లో, మనం యాక్సెస్ కోరుకుంటే
వ్యూహం యొక్క మొదటి మూలకం లేదా ఒక జాబితా మరియు నేను కాల్ వెళుతున్న
సమావేశం, argv వాదంతో వెక్టర్, కానీ ఆ మరింత దీర్ఘ ముందు.
నేను మొదటి మూలకం వద్ద పొందుటకు కావాలా స్క్రాచ్ ప్రపంచంలో యొక్క argv
మీరు నిజంగా సాధారణంగా 1 నుండి లెక్కింపు ప్రారంభించండి.
>> కాబట్టి నేను అంశం 1 argv యొక్క పొందండి ఉండవచ్చు.
ఆ MIT అమలు ఎంత జాబితాలు భావన.
కానీ సి లో, నేను వెళుతున్న కేవలం చెప్పటానికి, argv
ఇది మళ్ళీ యొక్క పేరు నా జాబితా లేదా స్పష్టతను, వ్యూహం.
మరియు నేను మొదటి అనుకుంటే అంశాలు, నేను వెళుతున్న
చదరపు బ్రాకెట్లలో ఉపయోగించడానికి, మీరు తరచుగా ఒక కీబోర్డ్ కింద ఉపయోగించబడదు ఉండవచ్చు.
>> కానీ 0 కేవలం నాకు మొదటి పొందండి.
కాబట్టి సందర్భంగా మరియు సమయం, వెళుతుంది, మేము వెళుతున్న
ఈ విరుద్ధంగా చూడడానికి స్క్రాచ్ మరియు C మధ్య,
అనగా స్క్రాచ్ ఒక ఉపయోగిస్తుంది.
సి లో మేము ఇక్కడ 0 ఉపయోగించండి.
కానీ మీరు త్వరగా చూస్తారు మీరు అర్థం ఒకసారి
ప్రతి భాషకు పునాదులు, ఆ ఈ విషయాలు అన్ని మరింత పొందడానికి ప్రారంభించండి
ఆచరణలో మరియు సాధన ద్వారా తెలిసిన.
>> కాబట్టి యొక్క అసలైన కార్యక్రమం వద్ద ఇప్పుడు చూద్దాం.
ఇక్కడ మా సి మొదటి ఉండాలి పూర్తి కార్యక్రమాలు సోర్స్ కోడ్.
మరియు కార్యక్రమం మేము వెళుతున్న పరిశీలనకు అందించే
సమానమైన వార్తలు అని ఒకటి పూర్వం స్క్రాచ్ పావు.
>> సో ఇక్కడ, మేము ఏమి కలిగి నిస్సందేహంగా సరళమైన సి కార్యక్రమం
మీరు ఆ వ్రాయగలరు నిజానికి ఏదో చేస్తాడు.
ఇప్పుడు, మేము గత పరిశీలిస్తాము, ఇప్పుడు కోసం, కార్యకర్తలను కలిగి ఉంది,
ప్రామాణిక io.h, మరియు ఈ కోణం బ్రాకెట్లలో, మరియు Int, మరియు శూన్యమైన,
మరియు గిరజాల జంట కలుపులు, మరియు వంటి.
>> మరియు లెట్స్ కేవలం దృష్టి వీలు ఏమి, అకారణంగా, కనీసం
ఇప్పటికే మీరు వద్ద జంప్ అవుట్.
నిజానికి, ప్రధాన, నాదగ్గర తప్పనిసరిగా ఈ తెలుసు,
ఎప్పుడయితే కానీ స్క్రాచ్ వంటి చూసారు ఆకుపచ్చ జెండా పజిల్ ముక్క క్లిక్
కాబట్టి ఒక ప్రోగ్రామింగ్ భాష వంటి C చేస్తుంది కోడ్ యొక్క ఒక ప్రధాన భాగం కలిగి
అప్రమేయంగా అమలు అవుతుంది. మరియు, నిజానికి, అది అక్షరాలా ప్రధాన అనే చేస్తాడు.
>> కాబట్టి ప్రధాన ఒక ఫంక్షన్ ఉంది.
మరియు అది ఉనికిలో ఉన్న ఒక ప్రత్యేక ఫంక్షన్ సి లో మీరు ఒక ప్రోగ్రామ్ అమలు చేసేటప్పుడు,
అది ద్వారా అమలు పొందే ప్రధాన ఉంది డిఫాల్ట్. స్క్రాచ్ ప్రపంచంలో,
ఇది సాధారణంగా ఉన్నప్పుడు ఆకుపచ్చ జెండా క్లిక్ సిద్ధంగా నడుస్తుంది కాకముందు.
>> ఇంతలో, మేము ముందు ఈ చూసిన, printf లేదా ముద్రణ ఫార్మాట్, ఆ
తో పాటు వచ్చే ఒక కార్యకలాపంగా అన్నారు సి, ఇతరుల మొత్తం బంచ్ పాటు,
సమయం మరియు సమయం నుండి ఆ ఇష్టానికి మళ్ళీ, క్రమంలో ఖచ్చితంగా చేయాలని
దాని పేరు సూచించిన విధంగా, ఏదో ప్రింట్.
మనం ప్రింట్ అనుకుంటున్నారు?
Well, మేము చూస్తారు జతపరచడం అక్షరాలు ద్వారా
these-- హలో ప్రపంచ వంటి, డబుల్ కోట్స్ లో బాక్ స్లాష్ n,
మేము ఖచ్చితంగా printf చెప్పడానికి చేయవచ్చు తెరపై ముద్రించడానికి ఏమి.
>> కానీ క్రమంలో చేయాలని ఆ, మేము దురదృష్టవశాత్తు
అని ఏదో తీసుకోవాలని అవసరం మాకు మానవులు ఇప్పటికే గుప్తమైన,
కానీ కనీసం అది కొంతవరకు పఠన వార్తలు పదునైన ఉన్నాయి, ప్రామాణిక io.h, Int,
ప్రధాన, శూన్యమైన, printf, మాయా అన్ని మంత్రోచ్చాటనల మేము కేవలం తెరపై చూసింది.
కానీ మేము నిజంగా కలిగి ఇప్పటికీ మరింత మర్మమైన వెళ్ళండి.
మేము మొదటి కోడ్ అనువాదం అవసరం మేము యంత్రం కోడ్ లోకి వ్రాసే.
మరియు చివరి వారం నుండి రీకాల్ యంత్రాలు అని, కనీసం వాటిని మేము ఇక్కడ తెలియజేస్తాము
రోజు చివరిలో మాత్రమే సున్నాలు మరియు వాటిని అర్థం.
>> నా దేవా, మేము కలిగి ఉంటే ఈ వ్రాయడానికి వాస్తవానికి కార్యక్రమానికి సున్నాలు మరియు వాటిని,
ఇది చాలా, చాలా త్వరగా చేస్తాను ఏదైనా సరదాగా అవుట్ పడుతుంది.
కానీ గత వారానికి హాజరవుతారు సున్నాలు మరియు వాటిని ఈ క్రమాలను
కేవలం ప్రత్యేక అర్ధం లేదు.
కొన్ని సందర్భాలలో, వారు సంఖ్యలు కావచ్చు.
>> కొన్ని సంధర్భాలలో, వారు కావచ్చు అక్షరాలు, లేదా రంగులు, లేదా ఎన్ని
అక్కడ మీద ఇతర భేదాలు ఉన్నాయి.
కానీ మీ కంప్యూటర్ ఉంది అంతే ఒక CPU, సెంట్రల్ ప్రాసెసింగ్ యూనిట్,
లేదా మీ కంప్యూటర్ లోపల మెదళ్ళు.
ఇది సాధారణంగా ఇంటెల్ వార్తలు లోపల, ఆ ఎందుకంటే
అతిపెద్ద సంస్థలలో ఒకటిగా కంప్యూటర్ ల కొరకు CPU లు చేస్తుంది.
>> బాగా, ఇంటెల్ CPU లు మరియు ఇతరులు కేవలం ముందుగానే నిర్ణయించుకున్నారు
సున్నాలు యొక్క నిర్దిష్ట నమూనాలు మరియు వాటిని నిర్దిష్ట విషయాలు అని అర్థం.
సున్నాలు మరియు వాటిని యొక్క నిర్దిష్ట నమూనాలు అర్థం, స్క్రీన్ ఈ ప్రింట్
లేదా ఈ రెండు సంఖ్యలు జోడించడానికి లేదా ఈ రెండు సంఖ్యలు వ్యవకలనం,
లేదా డేటా ఈ ముక్క తరలించు నా కంప్యూటర్ యొక్క మెమరీ ఇక్కడ పైగా,
లేదా ఇతర చాలా తక్కువ స్థాయిలో ఎన్ని, కానీ చివరికి ఉపయోగకరంగా, కార్యకలాపాలు.
కానీ, అదృష్టవశాత్తూ, మేము మానవులు వెళ్ళడం లేదు వివరాలు ఈ స్థాయి తెలుసుకోవాలి.
నిజానికి, కేవలం చివరిసారి ఇష్టం, మేము మళ్ళీ, మళ్ళీ, మళ్ళీ సంగ్రహించబడింది,
చాలా తక్కువ స్థాయి నుండి భవనం సున్నాలు మరియు వాటిని వంటి ధాతువులు
ఉన్నత స్థాయి భావనలు సంఖ్యలు మరియు అక్షరాల వంటి,
మరియు రంగులు, మరియు మరింత కాబట్టి మేము ప్రోగ్రామర్లు చెయ్యవచ్చు
నిల్చుకోండి ఎవరు మాకు ముందు వచ్చిన ఇతరులు
మరియు సాఫ్ట్వేర్ ఇతర ఉపయోగించడానికి ప్రజలు us-- ముందు రాసిన
అవి కార్యక్రమాలు కంపైలర్లు అని.
>> సి ఒక భాష అని సాధారణంగా, సంగ్రహించబడింది
నుండి మార్చబడుతుంది అంటే యంత్రం కోడ్ సోర్సు కోడ్.
ముఖ్యంగా, దీని అర్థం మీ సోర్స్ వచ్చింది ఉంటే అంటే చేసిన
మీరే త్వరలో వంటి, వ్రాసే కోడ్ తెరపై కేవలం ఒక క్షణం లో రెడీ,
మరియు మీరు మార్చే కావలసిన చివరికి యంత్రానికి ఉంటుంది కోడ్
ఆ సున్నాలు మరియు వాటిని ఆ మీ Mac లేదా మీ PC
understands-- మీరు ఒక మొదటి పొందారు వంటి ఆ సోర్స్ కోడ్ ఆహారం
ప్రత్యేక ఇన్పుట్ కార్యక్రమం ఒక కంపైలర్ అని,
అవుట్పుట్ ఇది మనం చూతురు యంత్రం కోడ్ ఉంది.
మరియు, నిజానికి, చివరిసారి మేము మాట్లాడారు గురించి నిజంగా ఆ రోజు చివరిలో,
సమస్య పరిష్కారం.
మీరు ఇన్పుట్లను పొందారు.
మరియు మీరు ప్రతిఫలాన్ని పొందారు.
మరియు మీరు రకమైన పొందారు మధ్యలో అల్గోరిథం యొక్క.
>> ఆల్గోరిథమ్స్ తప్పనిసరిగా ఉంటుంది సాఫ్ట్వేర్ అమలు,
మేము pseudocode గత వారం చూసింది గా మరియు మేము వాస్తవ కోడ్ తో చూస్తారు వంటి
ఈ వారం.
కాబట్టి ఒక కంపైలర్ నిజంగా కేవలం లోపల అల్గోరిథంలు సమితి ఉంది
అది తెలిసిన ఎలా ప్రత్యేక కీలక పదాలు మార్చేందుకు,
ప్రధాన, మరియు printf వంటి, మరియు ఇతరులు మేము కేవలం
సున్నాలు యొక్క నమూనాల్లో చూసిన వాటిని ఇంటెల్ లోపల మరియు ఇతర CPU లు
నిజానికి అర్థం.
సో ఎలా మేము ఈ చేస్తారు?
ఎక్కడ మేము ఒక కంపైలర్ వస్తుందా?
>> మాకు చాలా ఇక్కడ ఒక Mac లేదా PC.
మరియు మీరు Mac OS అమలు చేస్తుంటే, లేదా విండోస్, లేదా Linux లేదా సోలారిస్,
లేదా ఇతర ఏ సంఖ్య ఆపరేటింగ్ వ్యవస్థలు.
మరియు, నిజానికి, మేము అనుకొనుట వెబ్ లో బయటకు వెళ్ళి
మరియు ఒక కంపైలర్ డౌన్లోడ్ మీ Mac లేదా PC కోసం
మీ ఆపరేటింగ్ సిస్టమ్ కోసం.
కానీ మేము అన్ని ఉంటుంది వేర్వేరు పేజీల, మాట్లాడటానికి.
మేము కొద్దిగా భావిస్తాను వివిధ విన్యాసాలు.
మరియు విషయాలు ఒకే పని కాదు.
మరియు, నిజానికి, ఈ రోజుల్లో మనలో చాలా మంది వాడవద్దు
మా ల్యాప్టాప్లు లపై సాఫ్ట్వేర్.
బదులుగా, ఏదో ఉపయోగించడానికి ఒక బ్రౌజర్ వంటి
ప్రాప్తి అనుమతిస్తుంది వెబ్ ఆధారిత క్లౌడ్ లో అప్లికేషన్లు.
మరియు తరువాత ఈ సెమిస్టర్, మేము ఖచ్చితంగా ఆ చేస్తాను.
మేము అనువర్తనాలను రాయడం లేదా సాఫ్ట్వేర్ C కాదు ఉంటుంది కోడ్ ఉపయోగించి,
కానీ పైథాన్ వంటి ఇతర భాషలు మరియు క్లౌడ్ లో అమలు జావాస్క్రిప్ట్.
>> మరియు ఆ, మనం అలా సెమిస్టర్ సమయంలో
నిజానికి ఒక క్లౌడ్ ఆధారిత ఉపయోగిస్తుంది CS50 IDE వంటి తెలిసిన వాతావరణంలో.
ఈ వెబ్ ఆధారిత ప్రోగ్రామింగ్ ఉంది పర్యావరణం, లేదా ఇంటిగ్రేటెడ్ అభివృద్ధి
పర్యావరణం, IDE, ఆ కొన్ని పైన నిర్మించిన క్లౌడ్ 9 పిలుస్తారు ఓపెన్ సోర్స్ సాఫ్ట్వేర్.
మరియు మేము కొన్ని బోధనకు చేసిన దానికి సూక్ష్మీకరణల
కొన్ని లక్షణాలు దాచడానికి కాబట్టి మేము అవసరం లేని మొదటి వారాలలో,
తర్వాత మీరు చెయ్యవచ్చు వాటిని బహిర్గతం మరియు అలా చాలా
ఏదైనా మీరు పర్యావరణంతో అనుకుంటున్నారా.
>> దానికి చాలా, మాకు అనుమతిస్తుంది, నిర్దిష్ట సాఫ్ట్వేర్ ముందు ఇన్స్టాల్.
ఒక అని పిలవబడే CS50 వంటి విషయాలు మేము చేస్తాము వెంటనే చూస్తారు ఇది లైబ్రరీ
కొన్ని సి మాకు అందిస్తుంది అదనపు క్రియాశీలతను.
కాబట్టి మీరు వెళ్లి ఉంటే, చివరికి, CS50.io, మీరు లాగిన్ ప్రాంప్ట్ వస్తుంది,
మరియు మీరు మరియు సృష్టించడానికి ఒకసారి ఉచితంగా ఖాతాను,
మీరు ఒక యాక్సెస్ చెయ్యగలరు చాలా ఈ కనిపించే వాతావరణం.
>> ఇప్పుడు, ఈ డిఫాల్ట్ మోడ్ లో ఉంది.
ప్రతిదీ నైస్ మరియు తెరపై ప్రకాశవంతమైన.
మనలో చాలా మంది ఒక అలవాటు వార్తలు ఆ CS50 ముక్క పని
చాలా ఆలస్యంగా రాత్రి లోకి.
అందువలన మీరు కొన్ని ప్రాధాన్యం ఇవ్వవచ్చు అలా మాట్లాడటం రాత్రి మోడ్ లోకి మలుపు.
>> కానీ, చివరికి, మీరు ఉన్నాము CS50 IDE లోపల చూడండి వెళుతున్న
మూడు విభిన్న areas-- ఉంది వదిలి పేరు ఒక ప్రాంతం
మీ ఫైళ్లను ఉంటాయని క్లౌడ్, కుడివైపున ఒక ప్రాంతం
ఇక్కడ మీ కోడ్ సవరించగలిగేలా అవతరిస్తుంది.
మీరు తెరిచి చేయగలరు ఏ కార్యక్రమం కోసం వ్యక్తిగత టాబ్లను
మీరు ఈ సెమిస్టర్ లోపల వ్రాసే ఆ టాప్ కుడి చేతి మూలలో.
మరియు తర్వాత చాలా arcanely, మరియు ఇంకా శక్తివంతంగా,
ఈ విషయం అవతరిస్తుంది టెర్మినల్ విండో అని పిలుస్తారు దిగువన.
>> ఈ పాత పాఠశాల ఉంది కమాండ్ లైన్ ఇంటర్ఫేస్,
లేదా CLI కూడా అనుమతించే మీరు ఆదేశాలను అమలు
ఈ సందర్భంలో కంప్యూటర్ మీద, cloud-- కంప్యూటర్
మీ కోడ్ కంపైల్ వంటి పనులను సోర్స్ కోడ్ యంత్రం కోడ్,
మీ కార్యక్రమాలు అమలు చేయడానికి, లేదా ప్రారంభించడానికి మీ వెబ్ సర్వర్, లేదా మీ డేటాబేస్ ప్రాప్తి,
మరియు ఇతర పద్ధతులు ఎన్ని మేము దీర్ఘ ముందు ఉపయోగించడానికి ప్రారంభిస్తాము.
కానీ అక్కడ పొందడానికి, మేము ఉన్నాము నిజానికి పొందబోతున్నారు
వెళ్ళి ఆన్లైన్ మరియు ఆట ప్రారంభించడానికి.
మరియు ఆ విధంగా చేయడానికి, మొదటి చేసుకుందాం ప్రధాన తో tinkering మొదలు,
మరియు ఒక ప్రోగ్రామ్ యొక్క ప్రధాన భాగం వ్రాయండి.
మరియు యొక్క ఆ ఫంక్షన్ ఉపయోగించడానికి అనుమతిస్తున్నట్లు మేము ఇంతకు ముందు ఉపయోగించిన ఇది printf,
కేవలం ఏదో చెప్పటానికి.
>> కాబట్టి ఇక్కడ నేను CS50 IDE లోపల ఇప్పటికే am.
నేను ముందుగానే లాగిన్ చేసిన.
నేను పూర్తి విండో ప్రదర్శించారు.
కాబట్టి, చివరికి, మీరు చాలా వస్తున్న సమస్యలు లో
ఇదేవిధమైన చర్యలు అనుసరించే ఆన్లైన్ డాక్యుమెంటేషన్ అందిస్తుంది.
సో మీరు గురించి ఆందోళన అవసరం లేదు ప్రతి చిన్న సాంకేతిక అడుగు శోషణ
నేను ఈ రోజు ఇక్కడ ఆ.
>> కానీ మీరు ఈ వంటి ఒక స్క్రీన్ పొందుతారు.
నేను రాత్రి రీతిలో కావడం.
మరియు మీరు ప్రతిదీ ప్రకాశవంతం చేయవచ్చు రాత్రి మోడ్ నిలిపివేయబడుతుంది ద్వారా.
మరియు చివరిలో రోజు, మీరు చూడండి చూడాలని
ఈ మూడు ప్రధాన ఫైలు areas-- ఎడమవైపున బ్రౌజర్, టాప్ కోడ్ టాబ్లు,
మరియు దిగువన టెర్మినల్ విండో.
>> నాకు ముందుకు వెళ్లి నా మొదటి కార్యక్రమం వ్రాయండి.
నేను preemptively ఫైలు వెళ్ళండి వెళుతున్న సేవ్, మరియు hello.c వంటి నా ఫైలు సేవ్.
నిజానికి, సాంప్రదాయకంగా, ఏ కార్యక్రమం మేము సి భాషలో వ్రాయబడింది వ్రాయండి
ఏదో అనే ఉండాలని డాట్ సి సాంప్రదాయకంగా.
నేను ఎందుకంటే అది hello.c పేరు వెళుతున్న నేను ప్రపంచానికి హలో అంతరంలో.
ఇప్పుడు నేను జూమ్ వెళుతున్న బయటకు సేవ్ క్లిక్.
నేను ఇప్పుడు ఇక్కడ అన్ని ఒక టాబ్ ఉంది దీనిలో నేను కోడ్ రాయటం మొదలుపెట్టాలని.
>> ఈ కంపైల్ ఉండదని.
ఈ ఏమీ అర్థం.
నేను మార్చబడుతుంది కాబట్టి కూడా సున్నాలు మరియు వాటిని ఈ,
CPU ఏ కలిగి అన్నారు ఆలోచన చుట్టూ ఏమి జరగబోతోంది.
కానీ నేను ఆఫీసు వ్రాస్తే ఆ మ్యాచ్ లేదు సి యొక్క conventions-- సి ఉండటం తో,
మళ్ళీ, ఈ వంటి సింటెక్స్ లతో language-- ఈ హలో printf world-- మరియు నేను చేసిన
సౌకర్యవంతంగా సంపాదించిన కాలక్రమేణా ఈ చేయడం.
సో నేను చేసిన భావించడం లేదు ఏ టైపు చేసేటప్పుడు దొర్లే తప్పులను.
>> కానీ, స్థిరముగా, మొట్టమొదటి మీరు దీన్ని సమయం, మీరు అవుతుంది.
మరియు నేను గురించి వద్ద ఏమి చాలా వాటిని మొదటిసారిగా మీరు పనిచేయవు.
మరియు ఆ సంపూర్ణ సరే ప్రస్తుతం ఎందుకంటే మీరు
కేవలం అపూర్వము యొక్క మొత్తం చాలా చూడవచ్చు, కానీ మీరు తెలిసిన పొందుటకు ఒకసారి కాలక్రమేణా
ఈ వాతావరణంలో తో, మరియు ఈ భాష, మరియు ఇతరులు,
మీరు విషయాలు చూడటానికి ప్రారంభిస్తాము సరైన లేదా తప్పు గాని ఉంటాయి.
>> ఏమిటీ బోధన సభ్యులు మరియు కోర్సు
సహాయకులు పైగా సమయంలో అలా మంచి పొందుటకు, ఉంది మీ కోడ్ లో పొరపాట్లు లేదా దోషాలు చుక్కలు.
కానీ నేను ఆ దావా ఉంది ఈ కోడ్ లో బగ్స్ ఉన్నాయి.
నేను ఇప్పుడు ఈ కార్యక్రమం అమలు చేయండి.
>> ఇప్పుడు నా స్వంత Mac లేదా PC లో, నేను ఉన్నాను డబుల్ క్లిక్ చిహ్నాలు అలవాటు
నేను కొన్ని కార్యక్రమం అమలు కావలసినప్పుడు.
కానీ ఇక్కడ మోడల్ కాదు.
ఇది CS50 IDE ఈ పర్యావరణం, లో.
మేము ఒక ఆపరేటింగ్ ఉపయోగిస్తున్నారు Linux అనే వ్యవస్థ.
లినక్స్ మరో గుర్తుచేస్తుంది ఆపరేటింగ్ సిస్టమ్, అందరికి తెలిసిన
యూనిక్స్.
మరియు Linux ముఖ్యంగా ప్రసిద్ధి చెందింది ఒక కమాండ్ లైన్ పర్యావరణం, CLI కలిగి.
ఇప్పుడు, మేము ఒక నిర్దిష్ట ఉపయోగిస్తున్నట్లయితే ఉబుంటు అని Linux యొక్క రుచి.
మరియు ఉబుంటు కేవలం ఒక ఉంది Linux యొక్క కొన్ని వెర్షన్.
>> కానీ ఈ లైనక్స్ యొక్క ఈ రోజుల్లో వాస్తవానికి గ్రాఫికల్ వినియోగదారు ఇంటర్ఫేస్లు తో వస్తాయి.
మరియు మేము జరిగే ఒకటి ఇక్కడ ఉపయోగిస్తూ వెబ్ ఆధారిత ఉంది.
కాబట్టి ఈ కూడా ఒక చూడండి ఉండవచ్చు ఏదో నుండి కొద్దిగా భిన్నంగా
మీరే కలిగి ఉండవచ్చు చూసిన లేదా గతంలో అమలు.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న ఇప్పుడు క్రింది వాటిని.
నేను ఈ ఫైలు hello.c వంటి సేవ్ చేసిన.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు గణగణమని ద్వని చేయు సో రకం clanghello.c
సి భాషలో ఒక కంపైలర్ ఉంది.
ఇది ముందే వ్యవస్థాపించబడిన వార్తలు CS50 IDE లో.
మరియు మీరు ఖచ్చితంగా డౌన్లోడ్ చేసుకోవచ్చు మరియు మీ స్వంత Mac లేదా PC లో ఇన్స్టాల్.
>> కానీ, మళ్ళీ, మీరు అన్ని ఉండదనే ముందు ఆకృతీకరణ మీరు చేసిన.
కాబట్టి ఇప్పుడు కోసం, నేను రెడీ! clanghello.c అమలు కానుంది.
ఇప్పుడు ఈ సింటాక్స్ గమనించవచ్చు ఇక్కడ చివరికి రెడీ
నేను ఒక ఉన్నాను అని అర్థం గ్రహించడం ఫోల్డర్ లేదా డైరెక్టరీ కార్యస్థలం అని.
ఈ డాలర్ సైన్ కేవలం ఆచారం అర్థం కోసం ఇక్కడ మీ ఆదేశాలను టైప్ చేయండి.
>> ఇది కేవలం ఒక ప్రాంప్ట్ అని ఏమిటి సాంప్రదాయకంగా డాలర్ చిహ్నం.
నేను ఇప్పుడు ముందుకు వెళ్లి ఉంటే క్లిక్ ఎంటర్, ఏమీ జరగలేదు తెలుస్తోంది.
కానీ ఆ నిజానికి ఒక మంచి విషయం.
ఆ జరుగుతుంది తక్కువ మీ స్క్రీన్, ఎక్కువగా
మీ కోడ్ సరైన ఉండటం, కనీసం పదము.
>> నేను ఈ అమలు అనుకుంటే కాబట్టి ప్రోగ్రామ్, నేను ఏమి చేస్తారు?
సరే, ఆ అవుతుంది సాంప్రదాయకంగా అప్రమేయ పేరు
మీరు ఒక పేర్కొనండి లేనప్పుడు కార్యక్రమాలకు పేరు మీ ప్రోగ్రామ్ కేవలం a.out ఉంది.
మరియు చాలా ఈ వాక్యనిర్మాణం మీరు చేస్తాము దీర్ఘ ముందు తెలిసిన పొందండి.
>> డాట్ అర్థం, హే, CS50 స్లాష్ IDE, a.out అని పిలిచే ఒక కార్యక్రమం అమలు
నా ప్రస్తుత డైరెక్టరీ లోపల.
డాట్ ప్రస్తుత డైరెక్టరీ అర్థం.
మరియు మేము ఏమి ఇతర అట్లాంటి క్రమాల చూస్తారు అక్షరాలు చాలాకాలంపాటు అర్థం.
>> కాబట్టి ఇక్కడ మేము వెళ్ళండి ప్రపంచ హలో, ఎంటర్.
మరియు మీరు గమనించవచ్చు ఏమి ఉంది?
అది హలో ప్రపంచ ప్రింట్ లేదు.
ఇది కూడా తరలించబడింది తదుపరి లైన్ కర్సర్ను.
>> ఎందుకు ఉన్నారు?
మేము ముందు రాసిన కోడ్ ఏమిటి అందేలా కర్సర్ చేస్తాను
తరువాతి లైన్లో వెళ్ళి?
ఒక గురించి ఫన్నీ విషయం కంప్యూటర్ మాత్రమే జరగబోతోంది ఉంది
అక్షరాలా చేయాలని మీరు ఏమి ఏమి చెప్పాలి.
>> కాబట్టి మీరు హలో printf చెప్పాలి అయితే, కామా, స్పేస్, ప్రపంచ, దగ్గరగా కోట్,
ఇది వాచ్యంగా మాత్రమే జరగబోతోంది ఆ అక్షరాలు ముద్రించడానికి.
కానీ నేను ఈ ప్రత్యేక పాత్రను కలిగి ముగింపు, రీకాల్, బాక్ స్లాష్ n వద్ద.
మరియు ఆ అందేలా ఏమిటి పాత్ర వెళ్లిన
స్క్రీన్ తదుపరి లైన్.
>> నిజానికి, నాకు వెళ్ళి దీన్ని చూద్దాం.
నాకు ముందుకు వెళ్లి ఈ తొలగించండి లెట్.
ఇప్పుడు, నోటీసు నా స్క్రీన్ ఎగువన ఉంది
కొద్దిగా ఎరుపు కాంతి లో సూచిస్తూ టాబ్,
హే, మీరు మీ ఫైల్ సేవ్ చేసిన.
కాబట్టి నేను కంట్రోల్ ముందుకు వెళుతున్న S లేదా కమాండ్ ఎస్, ఫైలు సేవ్.
ఇప్పుడు అది ఒక క్షణం ఆకుపచ్చ వెళ్లాను goes--.
ఇప్పుడు అది తిరిగి వార్తలు కేవలం దగ్గరగా చిహ్నం ఉండటం.
>> నేను ఇప్పుడు మళ్ళీ clanghello.c అమలు చేస్తే, Enter, డాట్ స్లాష్, a.out, Enter,
మీరు ఇప్పటికీ పని అని చూస్తారు.
కానీ ఇది ఖచ్చితంగా కొంచెం బగ్గీ.
ప్రస్తుతం, నా ప్రాంప్ట్ కార్యస్థలం, ఆపై ఆ డాలర్ సైన్,
అప్పుడు నా అసలు ప్రాంప్ట్ ఒకే రేఖపై ఉంది.
కాబట్టి ఈ ఖచ్చితంగా ఒక సౌందర్య బగ్, అయినా ఇది నిజంగా ఒక తార్కిక బగ్ కాదు.
>> సో నేను కేవలం ఏమి దిద్దుబాటు రద్దుచెయ్యి వెళుతున్న.
నేను a.out తిరిగి వెళుతున్న.
నేను జోడించిన చేసిన ప్రకటన ఆ NEWLINE పాత్ర తిరిగి.
నేను ఫైలు సేవ్ చేసిన.
>> నేను, a.out తిరిగి వెళుతున్న and-- డ్యామిట్, ఒక బగ్, తప్పు అంటే బగ్.
సో బగ్ అయినప్పటికీ ఉంది నేను n ఉంది బాక్ స్లాష్ జోడించారు,
తిరిగి సేవ్, కార్యక్రమం తిరిగి నడిచింది ప్రవర్తన అదే జరిగింది.
ఎందుకు అని ఉంటుంది?
>> నేను ఒక అడుగు మిస్ చేస్తున్నాను కుడి?
ఆ కీలక దశ ముందు మీరు కలిగి ఉంది మీ సోర్స్ కోడ్ మారినప్పుడు ఆలోచన,
అది కూడా అమలు అవుతుంది కంపైలర్ ద్వారా
మళ్ళీ కాబట్టి మీరు కొత్త యంత్రం కోడ్ పొందండి.
యంత్రం కోడ్, సున్నాలు మరియు వాటిని,
దాదాపు ఒకేలా ఉంటాయని కానీ సంపూర్ణ అలా కాదు, మేము అవసరం ఎందుకంటే,
కోర్సు యొక్క, కొత్త లైన్.
>> కాబట్టి నేను అవసరం వెళుతున్న ఈ పరిష్కరించడానికి , Clanghello.c తిరిగి ఎంటర్, డాట్
స్లాష్, a.out.
మరియు ఇప్పుడు, హలో వరల్డ్ తిరిగి నేను ఉండదలిచారో దానిని ఉండాలి.
కాబట్టి ఈ అన్ని జరిమానా మరియు మంచి ఉంది.
కానీ a.out ఒక కోసం ఒక అర్ధరహిత పేరు కార్యక్రమం, అది నిర్మాణము అయినప్పటికీ,
చారిత్రక కారణాల కోసం, అసెంబ్లీ ఉద్గాతాలు అంటే అప్రమేయంగా.
>> కానీ నాకు ఇక్కడ ముందుకు వెళ్లి మనం మరియు భిన్నంగా దీన్ని.
నా హలో వరల్డ్ ప్రోగ్రామ్ కావలసిన నిజానికి హలో అని.
కనుక అది ఒక చిహ్నం ఉన్నాయి నా డెస్క్టాప్, అది a.out కాదు.
అది హలో అని.
>> సో దీన్ని, అది అవుతుంది గణగణమని ద్వని చేయు, అనేక ప్రోగ్రామ్లు వంటి
మద్దతు కమాండ్ లైన్ వాదనలు, లేదా జెండాలు, లేదా స్విచ్లు,
కేవలం దాని ప్రవర్తనను ఇది.
ముఖ్యంగా, గణగణమని ద్వని చేయు ఒక డాష్ o మద్దతు జెండా, అప్పుడు రెండవ పదం తీసుకుంటాయి.
ఈ సందర్భంలో, నేను ఏకపక్ష చేస్తాము, కానీ సహేతుక, హలో కాల్.
కానీ నేను ఏదైనా కాల్ కాలేదు నేను a.out తప్ప కోరుకుంటున్న
కాకుండా పాయింట్ పాటు ఉంటుంది.
>> ఆపై కేవలం పేరు పేర్కొనాలి ఫైలు యొక్క నేను కంపైల్ అనుకుంటున్నారు.
కాబట్టి ఇప్పుడు కూడా ప్రారంభంలో అయితే కమాండ్ నేను ఇప్పటికీ గణగణమని ద్వని చేయు కలిగి యొక్క,
ఆదేశం చివర నేను ఇప్పటికీ ఫైల్ పేరు కలిగి,
నేను ఇప్పుడు ఈ కమాండ్ లైన్ కలిగి వాదనలు, అంటున్నారు ఈ జెండాలు,
ఓహ్, మార్గం ద్వారా, అవుట్పుట్-ఓ, ఒక ఫైల్ డిఫాల్ట్ a.out హలో అని.
>> నేను కొట్టినప్పుడు ఇప్పుడు ఎంటర్, ఏమీ జరగలేదు తెలుస్తోంది.
మరియు, ఇంకా, ఇప్పుడు నేను డాట్ స్లాష్ హలో.
కనుక ఇది అదే కార్యక్రమం.
సున్నాలు మరియు వాటిని ఉంటాయి రోజు చివరిలో ఒకేలా.
>> కానీ వారు రెండు ఉన్నారని వివిధ ఫైళ్ళను a.out,
ఇది మొదటి వెర్షన్ మరియు కేవలం తెలివిలేక, అనే
మరియు ఇప్పుడు హలో, ఇది చాలా ఉంది ఒక కార్యక్రమం కోసం మరింత బలవంతపు పేరు.
కానీ, నిజాయితీగా, నేను ఎప్పుడూ am మళ్ళీ ఈ గుర్తు,
మళ్ళీ, మళ్ళీ.
మరియు, నిజానికి, మేము వ్రాయండి మరింత సంక్లిష్టమైన కార్యక్రమాలు,
మీరు ఆదేశాలను రాయడానికి పొందబోతున్నారు
కూడా పొందుటకు వెళ్తున్నారు మరింత ఇప్పటికీ క్లిష్టం.
>> కాబట్టి ఆందోళన లేదు.
ఇది అవుతుంది చింపాంజీలు మాకు చాలా వారు గ్రహించి
ఈ ఖచ్చితమైన అదే సమస్య వచ్చింది.
అవి చాలా కలిగి ఆనందించండి లేదు అతి పొడవైన, అద్భుత ఆదేశాలు టైప్
ఒంటరిగా వాటిని గుర్తు తెలియజేయండి.
కాబట్టి మాకు ముందు మానవులు చేసిన సులభంగా చేసే ఇతర కార్యక్రమాలు
మీ సాఫ్టువేరును కంపైల్ చేయుటకు.
>> మరియు, నిజానికి, అటువంటి కార్యక్రమం మేక్ అంటారు.
నేను ముందుకు వెళ్లి ఇలా వెళుతున్న.
నేను ప్రతిదీ దిద్దుబాటు రద్దుచెయ్యి వెళుతున్న నేను కేవలం క్రింది విధంగా చేశాడు.
నాకు ls టైప్ తెలియజేయండి.
మరియు మీరు మూడు గమనిస్తారు విషయాలు a.out, మరియు ఒక నక్షత్ర, హలో
మరియు ఒక స్టార్, మరియు hello.c.
ఆశాజనక, ఈ ఉండాలి కొద్దిగా సులభంగా ఉండాలి
అజమాయిషీ వంటి అంతకుముందు ఉంది ఈ వర్క్స్పేస్ని ఏమీ లేదు.
నేను ఉందని ఏమీలేవు మేము తరగతి ప్రారంభించారు వరకు సృష్టించింది.
>> మరియు నేను hello.c రూపొందించినవారు.
అప్పుడు కూడా నేను దీనిని సంకలనం, మరియు అది a.out అని.
ఆపై నేను కొద్దిగా దాన్ని మళ్ళీ కంపైల్ భిన్నంగా మరియు అది హలో అని.
కాబట్టి నేను ఈ డైరెక్టరీ లో మూడు ఫైళ్లు కలిగి, కార్యస్థలం ఈ ఫోల్డర్లో.
ఇప్పుడు, నేను అలాగే చూడగలరు నేను నిజానికి బయటకు జూమ్ ఉంటే.
>> నేను ఇక్కడ దూరంగా ఉంటే మరియు ఆ టాప్ కుడి చేతి చూడండి
మూలలో, ఎడమ వాగ్దానం వంటి మీ స్క్రీన్ వైపు
ఎల్లప్పుడూ మీరు చూపించడానికి అన్నారు మీ ఖాతాను వార్తలు, ఏమిటి
CS50 IDE లోపల.
మరియు మూడు ఫైళ్లు ఉన్నాయి ఉంది.
>> కాబట్టి నేను a.out వదిలించుకోవటం మరియు హలో పొందాలనుకోవడం.
మరియు మీరు వాటిని వంటి , అకారణంగా ఊహించుకోండి మీరు
నియంత్రణ క్లిక్ క్రమం కాలేదు లేదా ఈ క్లిక్ చెయ్యండి.
మరియు ఈ చిన్న మెనూ బయటకు.
మీరు ఫైల్ డౌన్లోడ్ చేసుకోవచ్చు, అమలు అది ప్రివ్యూ, రిఫ్రెష్, పేరు,
లేదా ఏ కాదు.
>> నేను కేవలం తొలగించండి కాలేదు, మరియు అది దూరంగా పెట్టారు.
కానీ యొక్క ఆదేశంతో పనులను చేస్తాయి ఇప్పుడు లైన్, సౌకర్యవంతమైన పొందుటకు కాబట్టి
ఈ తో, మరియు ఈ క్రింది.
నేను ముందుకు వెళ్లి తొలగించు వెళుతున్న అక్షరాలా rma.out టైప్ చేయడం ద్వారా a.out.
ఇది ఆదేశాలు అవుతుంది తొలగించడం లేదా ఏదో తొలగించడం,
తొలగించడానికి తొలగించుకోవచ్చు కాదు.
>> ఇది కేవలం సేవ్, మరింత క్లుప్తమైన ఆర్ఎం వార్తలు మీరు కొన్ని కీస్ట్రోక్, మరియు హిట్ నమోదు.
ఇప్పుడు మేము కొంతవరకు చూడాలని నిగూఢమైన సాధారణ ఫైల్ a.out తొలగించండి.
నేను నిజంగా ఏమి తెలియదు సక్రమంగా ఫైల్ ఇంకా ఉంటుంది.
కానీ నేను తొలగించడానికి అనుకుంటున్నారు.
>> కాబట్టి నేను అవును కోసం y టైప్ వెళుతున్న.
లేదా నేను దాన్ని టైప్ చేసి Enter నొక్కండి కాలేదు.
మరియు, మళ్ళీ, ఏమీ జరుగుతుంది ఉంది.
కానీ, సాధారణంగా, ఒక మంచి విషయం.
>> నేను ఈ సమయంలో రకం LS ఉంటే, నేను ఏమి చూస్తారు?
ఆశాజనక కేవలం హలో మరియు hello.c.
ఇప్పుడు, ఒక పక్కన, మీరు చేస్తాము ఈ స్టార్ గుర్తుతో గమనించవచ్చు,
నా కార్యక్రమాలు చివరిలో ఉంది.
మరియు వారు కూడా ఆకుపచ్చ కనపడక చేస్తున్నారు.
ఆ కేవలం CS50 IDE యొక్క మార్గం నిజానికి మీరు cluing ఆఫ్
ఆ సోర్స్ కోడ్ కాదు.
ఒక runnable ఒక ఎక్జిక్యూటబుల్ వార్తలు మీరు నిజంగా అమలు చేసే కార్యక్రమం
డాట్ స్లాష్ కలిగెను అప్పటి అది పేరు ఉంది.
>> ఇప్పుడు, నాకు ముందుకు వెళ్లి తొలగించడానికి ఈ హలో RM, Enter, సాధారణ తొలగించడానికి
అవును, హలో దాఖలు.
ఇప్పుడు నేను ls టైప్ చేస్తే మేము తిరిగి hello.c ఉన్నాము.
తొలగించడానికి లేదు ప్రయత్నించండి, మీ అసలు సోర్స్ కోడ్.
అయినప్పటికీ లక్షణాలు ఉన్నాయి CS50 IDE పేరు నిర్మించబడ్డ
మీరు మీ పునర్విమర్శ చరిత్రలో వెళ్ళే మరియు అనుకోకుండా మీరు సమయం లో రివైండ్
ఏదో తొలగించి, జాగ్రత్త ఉంటుంది ఏమి ఈ అడుగును అవునో కాదో ప్రకారం,
మీరు నిజంగా చేయాలనుకుంటున్నారా ఏమి.
నేను టాప్ వరకు వెళ్ళి ఉంటే ఇక్కడ ఎడమ చేతి మూలలో,
తోంది అన్ని hello.c ఉంది.
కాబట్టి పుష్పగుచ్ఛాలు ఉంది ఇతర ఆదేశాలను మీరు
Linux యొక్క ప్రపంచంలో అమలు చెయ్యవచ్చు, వీటిలో ఒకటి మళ్ళీ చేయండి, ఉంది.
మరియు మేము చేయండి చూడాలని నా కార్యక్రమం ఇప్పుడు అనుసరిస్తుంది.
>> బదులుగా గణగణమని ద్వని చేయడం, బదులుగా గణగణమని ద్వని-ఓ చేయడం,
నేను కేవలం వెళుతున్న అక్షరాలా హలో తయారు టైప్.
ఇప్పుడు నేను ఉన్నాను, గమనించవచ్చు hello.c చేయండి టైప్ లేదు.
నేను హలో తయారు టైప్ చేస్తున్నాను.
>> మరియు ఈ ప్రోగ్రామ్ చేయండి CS50 IDE, మరియు మరింత వస్తుంది
సాధారణంగా Linux తో, అని ఒక కార్యక్రమం
హలో అనే ప్రోగ్రామ్ సిధ్ధంగా.
మరియు అది, సాంప్రదాయకంగా, అనుకునేది జరగబోతోంది ఈ కార్యక్రమం తయారు చేయవచ్చు ఉంటే,
అది ఒక మూల నుంచి తయారు చేస్తాడు కోడ్ ఫైలు డాట్ సి ముగిసిన hello.c.
>> నేను కొట్టినప్పుడు నోటీసు, ఇప్పుడు ఎంటర్ చేసే అమలు అవుతుంది ఆ ఆదేశం
కూడా ఇక నిజానికి ముందు కంటే ముందు.
మేము చేసిన ఎందుకంటే మరియు ఆ కలిగి కన్ఫిగర్ CS50 IDE
ఆ నిర్మించారు కొన్ని అదనపు లక్షణాలు మేము ఇంకా అవసరం లేదు, కానీ వెంటనే రెడీ.
కానీ కీ విషయం గ్రహించడం నేను ఒక హలో ప్రోగ్రామ్ను ఇప్పుడు.
>> నేను మళ్ళీ రకం LS ఉంటే, నేను ఒక హలో ప్రోగ్రామ్ను.
నేను అమలు చేయవచ్చు డాట్ ఏ a.out స్లాష్,
ఈ మొత్తం పాయింట్ ఎందుకంటే వ్యాయామం డాట్ స్లాష్ హలో ఉంది.
ఇప్పుడు నా హలో వరల్డ్ ప్రోగ్రామ్ కలిగి.
సో ముందుకు వెళ్లడానికి, మేము దాదాపు ఎల్లప్పుడూ ఉన్నాము
మా కార్యక్రమాలు కంపైల్ వెళుతున్న కమాండ్ ఉపయోగించి తయారు.
ఆపై మేము వాటిని అమలు చూడాలని డాట్ స్లాష్, మరియు ప్రోగ్రామ్ యొక్క పేరు.
కానీ చేస్తోంది చేయండి అనేదానికి మీరు అది ఒక కంపైలర్ కూడా ఉంది.
ఇది కేవలం ఒక సౌలభ్యం కార్యక్రమం ఒక కంపైలర్ ట్రిగ్గర్ ఎలా తెలుసు
మీరు అది మిమ్మల్ని మీరు ఉపయోగించే కాబట్టి అమలు.
>> ఏ ఇతర ఆదేశాలను ఉనికిలో Linux, మరియు క్రమంగా CS50 IDE లో?
మేము వెంటనే అక్కడ చూస్తారు CD ఆదేశం మార్చు డైరెక్టరీ.
ఈ లోపల మీరు అనుమతిస్తుంది మీ ఆదేశ ఇంటర్ఫేస్
ముందుకు తరలించడానికి, మరియు తిరిగి, మరియు వివిధ ఫోల్డర్లలో తెరుచుకుంటుంది
మీ మౌస్ ఉపయోగించి లేకుండా.
>> జాబితా కోసం నిలుచునే మేము చూసిన ఎల్ఎస్, ప్రస్తుత డైరెక్టరీలో ఫైళ్లు.
డిర్, మీరు చెయ్యవచ్చు బహుశా ప్రతిపాదించే మొదలు
ఈ ఇప్పుడు డైరెక్టరీ తయారు అర్థం ఏమి, మీరు ఒక ఫోల్డర్ సృష్టించడానికి కావాలా.
తొలగిస్తాయి ను RM, RM కోసం డిర్ డైరెక్టరీ మరియు ఈ తొలగించడానికి,
మళ్ళీ, కమాండ్ లైన్ మీరు ఏమి సమానంగా
మీ మౌస్ తో CS50 IDE లో పని చేయడు.
కానీ మీరు వెంటనే పొందుతారు కొన్నిసార్లు అది కేవలం
వేగంగా చేస్తాను ఒక కీబోర్డ్ విషయాలు,
చివరకు ఒక చాలా శక్తివంతమైనవి.
>> కానీ ఆ వాదించాడు కష్టం ఏదైనా మేము ఇప్పటివరకు చేయడం చేసిన
అంతా ఆ శక్తివంతమైన ఉంది, మేము మాట్లాడుతూ చేసిన హలో ప్రపంచ.
మరియు, నిజానికి, నేను hardcoded నా కార్యక్రమం హలో వరల్డ్ పదాలు.
ఇంకా ఎటువంటి చైతన్యానికి ఉంది.
స్క్రాచ్ భారీ ఆర్డర్ ఉంది ఆసక్తికరమైన గత వారం.
>> కాబట్టి యొక్క అక్కడ పొందుటకు వీలు.
ల చే ఆ వైపు ఒక అడుగు తీసుకుందాం ఈ పనులను కొన్ని మార్గం.
సో మాత్రమే సి printf తో వస్తాయి లేదు, మరియు ఇతర విధులు పుష్పగుచ్ఛాలు
వీటిలో కొన్ని మేము చూస్తారు కాలక్రమేణా, అది లేదు
కుడి దాన్ని అన్ని అంత సులభం చేయడానికి యూజర్ ఇన్ పుట్ లో ద్వారం.
>> నిజానికి, బలహీనతలు ఒకటి సి వంటి భాషలు,
మరియు కూడా జావా మరియు ఇంకా ఇతరులు, అది కాదు ఆ ఉంది
అది కేవలం వంటి విషయాలు పొందుటకు సులభం వినియోగదారులు, లేదా తీగలను, పదాలు వాడె పూర్ణ,
మరియు పదబంధాలు వంటి ఒక్క విషయాలు వీలు ఫ్లోటింగ్ పాయింట్ విలువలు, లేదా వాస్తవ సంఖ్యలు
డెసిమల్ పాయింట్లు, మరియు నిజంగా పొడవు నంబర్లు, మేము వెంటనే చూస్తారు వంటి.
కాబట్టి ఇక్కడ విధులను ఈ జాబితా, ఈ ఇతర పజిల్ ముక్కలు స్క్రాచ్ వంటివే
మేము CS50 లో ముందుగానే ఇన్స్టాల్ చేసిన మేము కొన్ని వారాల కోసం ఉపయోగిస్తాము IDE
రకాల శిక్షణ చక్రాలు, మరియు చివరకు వాటిని టేకాఫ్, మరియు చూడండి
హుడ్, బహుశా వద్ద క్రింద ఈ విషయాలు ఎలా అమలు చేస్తారు.
>> కానీ దీన్ని, లెట్స్ నిజానికి ఒక ప్రోగ్రామ్ను రాయడం.
నాకు ఇప్పుడు ముందుకు వెళ్ళి తెలపండి.
మరియు నేను ఒక కొత్త సృష్టించడానికి వెళుతున్న ఈ చిన్న ప్లస్ క్లిక్ చేయడం ద్వారా దాఖలు
మరియు కొత్త ఫైల్ క్లిక్.
>> నేను ఈ తదుపరి సేవ్ వెళుతున్న వంటి, యొక్క అని పిలవబడు ఒక, string.c,
నేను తీగలను ఆడటానికి కావలసిన ఎందుకంటే.
మరియు సి స్ట్రింగ్ కేవలం ఉంది అక్షరాలు క్రమం.
కాబట్టి ఇప్పుడు యొక్క ముందుకు వెళ్లి మనం , క్రింది వాటిని.
>> ప్రామాణిక IO.h-- చేర్చండి మరియు అది ప్రామాణిక IO అవుతుంది
ఐఓ కేవలం ఇన్పుట్ మరియు అవుట్పుట్ అర్థం.
కనుక ఇది హాజరవుతారు ఇక్కడ ఈ లైన్ ఏమిటి
printf ఉపయోగించడానికి మాకు పొరుగు ఉంది.
Printf, కోర్సు యొక్క, ఇది ఉత్పత్తి చేస్తుంది.
కాబట్టి printf ఉపయోగించడానికి క్రమంలో, ఇది మారుతుంది బయటకు మీరు కోడ్ యొక్క ఈ లైన్ కలిగి
మీ ఫైల్ ఎగువన.
>> మరియు మేము తిరిగి వచ్చి ఉంటుంది ఏమి నిజంగా దీర్ఘ ముందు అర్థం.
ఇది హాజరవుతారు ఏ సి కార్యక్రమం నేను రాయడం,
నేను తో మొదలు పొందారు ఈ కనిపించే కోడ్.
మీరు CS50 IDE గమనించవచ్చు ఉంటాం ఇతర సమగ్ర అభివృద్ధి
అది వంటి పర్యావరణాల్లో, ఉత్తమ ప్రయత్నించండి వెళుతున్న
వారు మీ ఆలోచన పూర్తి చేయవచ్చు.
నిజానికి, ఒక క్షణం క్రితం నేను దిద్దుబాటు రద్దుచెయ్యి ఉంటే నేను కేవలం ఏమి, నేను Enter నొక్కండి.
>> నేను అప్పుడు ఓపెన్ గిరజాల హిట్ జంట కలుపు, మళ్ళీ నొక్కండి.
మరియు అది నా ఆలోచన ముగిసింది.
ఇది నాకు ఒక కొత్త లైన్ ఇచ్చింది తక్కువ ఇండెంట్ nice శైలీకృత కారణాల మేము చూస్తారు.
మరియు అది స్వయంచాలకంగా నాకు ఇచ్చిన నా ఆలోచన పూర్తి వంకర కలుపు.
ఇప్పుడు, ఇది ఎల్లప్పుడూ లేదు మీరు చేయాలనుకుంటున్నారా ఏమి అంచనా.
కానీ అధిక భాగం లో, అది మీరు కొన్ని కీ స్ట్రోకులను సేవ్.
సో, ఒక క్షణం క్రితం, మేము ఈ ప్రోగ్రామ్ నడిచింది హలో, ప్రపంచం, మరియు అప్పుడు అది సంకలనం
ఆపై నడిచింది.
కానీ ఇక్కడ ఎటువంటి చైతన్యానికి ఉంది.
మేము కోరుకుంటే ఏమిటి వివిధ ఏదో చేయాలని?
బాగా, నేను నిజానికి కోరుకుంటే వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందండి?
నేను ఒక పజిల్ ముక్క ఉపయోగించడానికి వెళుతున్న ఆ స్ట్రింగ్ పొందండి ఖచ్చితంగా అని.
>> సి హాజరవుతారు మీరు వద్దు ఉన్నప్పుడు ఒక పజిల్ ముక్క ఇన్పుట్ను అందించాలి,
లేదా మరింత సరిగ్గా ఒక ఫంక్షన్, మీరు అక్షరాలా, ఓపెన్ కుండలీకరణములలో
దగ్గరగా కుండలీకరణములలో.
కనుక ఇది లేనప్పటికీ వార్తలు టైప్ ఎటువంటి వైట్ బాక్స్.
సే బ్లాక్ ముందు ఒక చిన్న తెల్ల బాక్స్ కలిగి.
మేము ఇప్పుడు తెలుపు బాక్స్ లేదు.
>> కానీ నేను స్ట్రింగ్ కాల్ చేసినప్పుడు, నేను ఎక్కడో ఫలితంగా ఉంచాలి కావలసిన.
కాబట్టి సి లో చాలా సాధారణ సమాహారం ఉంది ఇక్కడ జరిగిన ఒక కార్యక్రమంలో స్ట్రింగ్ వంటి, కాల్,
ఆపై తిరిగి విలువ నిల్వ.
ఇది ఫలితంగా దాని ఏదో ప్రయత్నం.
>> మరియు ఏమిటి ప్రోగ్రామింగ్ నిర్మించడం,
, ఇప్పుడు మేము సి స్క్రాచ్ లో లేదో నిజానికి ఏదో నిల్వ ఉపయోగించవచ్చు?
అది కుడి ఒక వేరియబుల్ అని?
మరియు స్క్రాచ్ లో, మేము నిజంగా వేరియబుల్స్ వెళుతున్నాను ఏమి పట్టించుకోను.
>> కానీ ఈ సందర్భంలో, మనం నిజంగా.
నేను స్ట్రింగ్ చెప్పడానికి వెళుతున్నాను.
ఆపై నేను కాల్ కాలేదు ఈ ఏదైనా నేను కావలసిన.
నేను కాల్ వెళుతున్న పేరు, స్ట్రింగ్ పొందండి పొందుతాడు.
>> ఇప్పుడు మీరు ఉన్నాము అయినా ఈ ఒక చిన్న కొత్త,
నేను కొన్ని వివరాలు లేకపోవడంపై వెబ్ గమనించవచ్చు.
నేను ఒక సెమీ కోలన్ మర్చిపోకుండా చేస్తున్నాను.
నేను ఈ ఆలోచన పూర్తి చేయాలి.
నేను, నా కర్సర్ తరలించడానికి వెళుతున్న మరియు అక్కడ సెమీ కోలన్ హిట్.
మరియు నేను ఏమి చేసారు?
కోడ్ యొక్క ఈ లైన్ లో, క్షణం వద్ద సంఖ్య 5,
నేను ఏ ఇన్పుట్లను తో స్ట్రింగ్ పొందండి కాల్ చేస్తున్నాను.
కాబట్టి ఏ చిన్న తెలుపు ఉంది బ్లాక్ సేవ్ ఉన్నట్లు బాక్స్.
>> నేను కేవలం hey చెప్పడం, కంప్యూటర్, నాకు ఒక స్ట్రింగ్ పొందండి.
సమాన సైన్ నిజంగా కాదు సమాన సైన్ కేవలంగా.
ఇది కార్య కాదు అంటే ఆపరేటర్లు,
హే, కంప్యూటర్, విలువ తరలించడానికి ఎడమ మీద కుడి నుండి.
మరియు ఎడమ, నేను అనుసరించే వారు.
>> హే, కంప్యూటర్, నాకు ఒక స్ట్రింగ్ ఇవ్వాలని అక్షరాలు క్రమం.
మరియు ఆ స్ట్రింగ్ పేరు కాల్.
నేను కూడా అది పేరు కాల్ లేదు.
>> నేను సంప్రదాయకంగా, కాల్, ఎస్ అలాంటిదే
మేము i ఉపయోగించే అనే వేరియబుల్ నేను కాల్.
కానీ ఇప్పుడు నేను ఏదో ఒకటి చేయాలి.
దానికి అర్ధరహిత ఉంటుంది నడుస్తున్న ఈ కోడ్ కంపైల్ ప్రయత్నించండి,
ఈ కార్యక్రమం అయినప్పటికీ నేను ఒక స్ట్రింగ్ పొందుతున్నాను,
అది ఇప్పటికీ కేవలం ఎందుకంటే హలో ప్రపంచ చెప్పటానికి వెళుతున్న.
>> కానీ నేను ఈ మార్చడానికి ఏమి అనుకుంటున్నారు ఉంటే.
నేను దీన్ని ఎందుకు లేదు?
శాతం లు, కామా లు.
మరియు ఇది ఇప్పటికీ ఒక చిన్న గుప్తమైన ఉంది.
>> నాలో నా వేరియబుల్స్ మరింత స్పష్టమైన చేయడానికి వీలు.
నాకు ఈ వేరియబుల్ పేరు పేరు లెట్.
మరియు మేము బాధించటం కాదు లేదో యొక్క చూసేలా ఇక్కడ కాకుండా ఏమి జరుగుతున్నది.
>> కాబట్టి లైన్ ఐదు, నేను ఒక స్ట్రింగ్ పొందుతున్నాను.
నేను ఆ స్ట్రింగ్ నిల్వ చేస్తున్నాను, సంసార వినియోగదారు టైప్
అతని లేదా ఆమె కీబోర్డ్ వద్ద, పేరు అనే వేరియబుల్.
మరియు ఆ అవుతుంది printf కేవలం చేస్తుంది
డబుల్ ఒక వాదన పడుతుంది కోట్స్, డబుల్ కోట్స్ లో ఒక ఇన్పుట్.
>> ఇది రెండు, లేదా మూడు, లేదా మరింత, అటువంటి పట్టవచ్చు రెండవ, లేదా మూడవ, లేదా నాలుగోవంతు,
వేరియబుల్స్ యొక్క అన్ని పేర్లే లేదా ప్రత్యేకంగా, విలువలు
మీరు ప్లగ్ కావలసిన, డైనమిక్, కోట్స్ లో స్ట్రింగ్.
ఇతర మాటలలో, ఏమి ఈ తప్పు అవుతుంది?
నేను చెప్పి ఉంటే పేరు హలో, బాక్ స్లాష్ n, నా ఫైలు సేవ్, నా కోడ్ సంకలనం
మరియు ఈ పరుగెత్తి ఏమి జరుగుతుంది?
>> ఇది కేవలం చెప్పడానికి జరగబోతోంది హలో పేరు అక్షరాలా ఎన్ ఎ ఎం-ఇ,
ఏ రకమైన ఎందుకంటే తెలివితక్కువదని ఉంది ప్రపంచం నుండి ఎటువంటి విభిన్నమైనది.
కాబట్టి కోట్లు ఏదైనా ఉంది సాహిత్యపరంగా ప్రింట్ అవుతుంది.
నేను కలిగి అనుకుంటే కాబట్టి అక్కడ ఒక ప్లేస్హోల్డర్,
నేను నిజంగా ఉపయోగించడానికి అవసరం కొన్ని ప్రత్యేక సింటాక్స్.
మీరు చదివిన ఉంటే అది అవుతుంది printf ఫంక్షన్ కోసం డాక్యుమెంటేషన్,
ఆ ఇత్సెల్ఫ్ మీరు శాతం లు ఉపయోగిస్తే,
ఈ కింది విధంగా మీరు ఒక విలువను ప్రత్యామ్నాయంగా ఉండడం.
>> ఆ తర్వాత ఒక కామా తర్వాత డబుల్ కోట్, మీరు కేవలం
పేరు వ్రాయండి మీకు కావలసిన వేరియబుల్
ఆ ఫార్మాట్ లోకి ప్లగ్ కోడ్, లేదా ఫార్మాట్ నిర్దేశకాన్ని
తీగలను కోసం శాతం లు.
ఇప్పుడు నేను నా ఫైల్ సేవ్ ఉంటే, నా టెర్మినల్ తిరిగి డౌన్ వెళ్ళండి.
నేను స్ట్రింగ్ చేయండి టైప్ ఎందుకంటే, మళ్లీ, దీని పేరు
నేను ముందు ఎంచుకున్నాడు ఆ ఫైల్ string.c ఉంది.
>> నేను స్ట్రింగ్ చేయండి నమోదు చెప్పడానికి వెళుతున్నాను.
మంచితనం ఓహ్, అన్ని చూడండి తప్పులు మేము ఇప్పటికే చేసిన.
మరియు ఈ ఏమి, ఈ నిజంగా మాదిరిగా ఆరు, ఏడు లైన్ కార్యక్రమం వలె?
కాబట్టి ఈ చాలా ఇవ్వలేదు వెంటనే అధిక పొందుటకు.
>> ఈ టెర్మినల్ విండో ఉంది ఇప్పుడు కేవలం regurgitated
దోష సందేశాలు భారీ సంఖ్యలో.
ఖచ్చితంగా, నేను మరింత లోపం లేదు నేను కంటే సందేశాలను లైన్స్ ఆఫ్ కోడ్ కలిగి.
కాబట్టి ఏం జరుగుతుందో?
>> Well, ఉత్తమ వ్యూహం ఎప్పుడైనా మీరు చెయ్యవలసింది
అధిక ఎదుర్కునే లేదు ఆ వంటి లోపాలు జాబితా
తిరిగి స్క్రోల్ ఉంది, కమాండ్ కోసం చూడండి మీరు కేవలం నడిచింది నా విషయంలో ఇది
స్ట్రింగ్ చేయడానికి ఉంది.
చేసింది ఏమి చూడండి, మరియు ఆ ఆ దీర్ఘ గణగణమని ద్వని చేయు ఆదేశం, ఏ పెద్ద ఒప్పందం.
>> కాని ఎర్ర చెడ్డది.
గ్రీన్ ఉంటుంది ప్రయత్నిస్తున్నారు సున్నితమైన మరియు ఉపయోగపడిందా.
కానీ ఈ సందర్భంలో, ఇప్పటికీ దురదృష్టకరం.
కానీ అది చెడ్డది?
>> String.c, లైన్ ఐదు, పాత్ర ఐదు.
ఈ కేవలం సాధారణ ఆచారం.
ఏదో పెద్దప్రేగు అర్ధం లైన్ సంఖ్య మరియు పాత్ర సంఖ్య.
లోపం, అస్పష్టమైన ఉపయోగం ఐడెంటిఫైయర్ స్ట్రింగ్.
మీరు ప్రామాణిక అడిగారా?
>> సో, దురదృష్టవశాత్తు, గణగణమని ద్వని చేయు ఉపయోగపడిందా ఉంటుంది ప్రయత్నిస్తున్నారు.
కానీ ఈ సందర్భంలో, తప్పు.
లేదు, గణగణమని ద్వని చేయు, నేను ప్రామాణిక IO ఉద్దేశ్యం కాదు.
నేను అవును, రేఖ ఒక ఆ అర్థం.
>> కానీ లైన్ ఐదు ఇక్కడ ఈ ఒకటి.
మరియు గణగణమని ద్వని చేయు లేదు అర్థం ఎస్ టి ఆర్-ఐ-ఎన్-జి.
ఇది ఒక అస్పష్టమైన గుర్తింపు, ఒక వార్తలు అది కేవలం ముందు చూడలేదని పదం.
మరియు ఆ ఎందుకంటే C, భాష మేము ఇప్పుడు లో కోడ్ రాస్తున్నాం,
తీగలను అని వేరియబుల్స్ లేదు.
>> ఇది డిఫాల్ట్, మద్దతు లేదు, ఏదో ఒక స్ట్రింగ్ అని.
ఆ ఒక CS50 ముక్క వార్తలు పడికట్టు, కానీ చాలా సాంకేతికమైన.
ఈ క్రింది విధంగా కానీ నేను ఈ పరిష్కరిస్తాము.
>> నేను కోడ్ యొక్క ఒక లైన్ జోడిస్తే ఈ ప్రోగ్రామ్ యొక్క టాప్,
ఇది మరొక ఫైల్, CS50.h ఉన్నాయి CS50 IDE లోపల ఎక్కడో ఎక్కడో
హార్డు డ్రైవు, మాట్లాడటానికి, ఉబుంటు ఆపరేటింగ్ సిస్టమ్ యొక్క
నేను నడుస్తున్న చేస్తున్నాను, ఆ ఆ ఫైలు
ఆపరేటింగ్ నేర్పిన వెళ్తున్నారు వ్యవస్థ ఏమి ఒక స్ట్రింగ్, కేవలం
ప్రామాణిక io.h వంటి ఫైల్ ఉంది ఆ ఆపరేటింగ్ సిస్టమ్ లో
ఉంది ఏమి printf బోధించే అన్నారు.
>> నిజానికి, మేము సంపాదించిన ఉండేది ఇలాంటి సందేశాన్ని
ఐఓ ప్రామాణిక ఒప్పుకున్నప్పుడు ఉంటే Io.h మరియు printf ఉపయోగించడానికి ప్రయత్నించాడు.
నేను ముందుకు మరియు కేవలం వెళ్ళి వెళుతున్న నా స్క్రీన్ క్లియర్ కంట్రోల్ L పడుతుంది.
లేదా మీరు స్పష్టమైన టైప్ మరియు అది చేయవచ్చు కేవలం టెర్మినల్ విండో క్లియర్.
అయితే మీరు ఇప్పటికీ సమయం లో తిరిగి స్క్రోల్ చేయవచ్చు.
>> నేను తిరిగి కు స్ట్రింగ్ చేయండి వెళుతున్న.
నా వేళ్లు ఈ సమయంలో క్రాస్ ఎంటర్.
ఓహ్ మై గాడ్, అది పనిచేసింది.
ఇది నాకు చాలా గుప్తమైన ఆదేశం చూపిస్తుంది గణగణమని ద్వని చేయు ద్వారా ఉత్పత్తి ఏమి ఉంది,
కానీ ఏ లోపం సందేశాలు.
ఆ, తెలుసుకుంటారు అయినప్పటికీ మీరు పూర్తిగా పొందండి ఉండవచ్చు
నిష్ఫలంగా దోష సందేశాలు సంఖ్య,
అది కేవలం ఈ బాధించే కాస్కేడింగ్ కావచ్చు ప్రభావం, గణగణమని ద్వని చేయు అర్థం లేదు పేరు
అప్పుడు అది అంటే ఒక విషయం, తదుపరి పదం అర్థం లేదు,
లేదా తదుపరి లైన్.
కాబట్టి ఇది మీ కోడ్ లో ఉడుంపట్టులను.
కానీ పరిష్కారము సాధారణ కావచ్చు.
కాబట్టి ఎల్లప్పుడూ దృష్టి అవుట్పుట్ యొక్క మొట్టమొదటి లైన్.
మరియు మీరు లేకపోతే అది అర్థం, కేవలం చూడండి
కీలక పదాలు కోసం చెయ్యదగిన ఆధారాలు, మరియు లైన్ సంఖ్య,
ఎక్కడ పాత్ర, ఆ తప్పు కావచ్చు.
>> ఇప్పుడు నాకు ముందుకు వెళ్లి టైప్ తెలియజేయండి డాట్ స్లాష్, స్ట్రింగ్, ఎంటర్.
అవును, అది హలో ఏమీ మాట్లాడకుండా కాదు.
ఎందుకు?
సరే, ఇక్కడ నడుస్తున్న గుర్తుకు?
>> ఇది బహుశా సమయంలో కష్టం ఒక లూప్ లో, మీరు రెడీ ఉంటే లైన్ ఆరు,
డిజైన్ స్ట్రింగ్ పొందండి ఎందుకంటే, CS50 సిబ్బంది రాసిన,
అక్షరాలా కేవలం కూర్చుని అర్థం అక్కడ వేచి, మరియు వేచి,
మరియు ఒక స్ట్రింగ్ కోసం వేచి.
మేము స్ట్రింగ్ అర్ధం మానవ ఇన్పుట్ ఉంది.
కాబట్టి మీరు ఏమి?
నాకు ముందుకు వెళ్ళి తెలపండి.
మరియు కేవలం ఒక ఊహించని రీతిలో, నాకు తెలియజేయండి నా పేరు, డేవిడ్ టైప్ ఎంటర్.
ఇప్పుడు నేను మరింత డైనమిక్ ప్రోగ్రామ్ను.
అది హలో డేవిడ్ చెప్పారు.
>> నేను ముందుకు వెళ్లి మళ్లీ ఈ అమలు చేస్తే, నాకు నమోదు Zamila పేరు చెబుతారు ప్రయత్నించండి లెట్.
మరియు ఇప్పుడు మేము ఒక డైనమిక్ ప్రోగ్రామ్ను.
నేను హార్డ్ కోడెడ్ ప్రపంచ లేరు.
నేను హార్డ్ కోడ్ లేదు పేరు, లేదా డేవిడ్, లేదా Zamila.
>> ఇప్పుడు అది కార్యక్రమాలు వంటి మరింత వార్తలు ఇది ఇన్పుట్ పడుతుంది ఉంటే మేము, తెలిసిన,
కాస్త భిన్నంగా ఉత్పత్తి చేస్తుంది.
ఇప్పుడు, ఈ ఉత్తమ కాదు యూజర్ అనుభవం, లేదా UX.
నేను అమలు.
>> నేను కోరుకుంటున్నాము నేను ఏమి తెలియదు , అలా నేను నిజానికి చూడండి తప్ప
లేదా సోర్స్ కోడ్ గుర్తు.
కాబట్టి యొక్క వినియోగదారు తయారు చేద్దాము కొద్దిగా మెరుగ్గా అనుభవించడానికి
వాటిని సాధారణ తో.
నాకు ఈ లోకి వెళదాం కార్యక్రమం, మరియు కేవలం printf చెప్పడానికి.
>> మరియు నాకు ముందుకు వెళ్లి పేరు, కోలన్ అని పిలవబడు, మరియు ఒక స్పేస్ ఆపై ఒక సెమీ కోలన్.
మరియు కేవలం కిక్స్ కోసం, ఏ ఎదురుదెబ్బ n.
మరియు ఆ ఉద్దేశపూర్వకంగా వార్తలు, నేను అనుకుంటున్న ఎందుకంటే
ప్రాంప్ట్ తదుపరి లైన్ తరలించడానికి.
>> నేను, బదులుగా, ఈ చేయాలనుకుంటున్నారా, స్ట్రింగ్ చేయడానికి కొత్త యంత్రం లోకి నా కోడ్ కంపైల్ చెయ్యండి
కోడ్ డాట్ స్ట్రింగ్ స్లాష్.
అమ్మో, ఈ చాలా prettier ఉంది.
ఇప్పుడు నేను ఏమి కంప్యూటర్ తెలుసుకోవాలి నాకు, అది ఒక పేరు ఇవ్వాలని కోరుతుంది.
>> నేను ముందుకు వెళ్లి టైప్ వెళుతున్న రాబ్, ఎంటర్, హలో, రాబ్.
కాబట్టి, తెలుసుకుంటారు ఈ ముగింపు వద్ద, ఇప్పటికీ ఉంది రోజు, తొమ్మిదేళ్ళ లైన్ కార్యక్రమం.
కానీ మేము ఈ బిడ్డ దశలను తీసుకున్నారు.
>> మేము ఒక లైన్ రాసింది తో మేము తెలిసిన printf, హలో వరల్డ్.
తర్వాత ఆ కొద్దిగా undid.
మరియు మేము నిజంగా ఉపయోగించినపుడు స్ట్రింగ్ పొందండి.
మరియు మేము ఒక వేరియబుల్ ఆ విలువ విసిరిన.
మరియు తర్వాత మేము ముందుకు వెళ్లి మెరుగైన అది మూడవ లైన్ తో మరింత.
మరియు ఈ ప్రక్రియ పునరుత్థాన సాఫ్ట్వేర్ రాయడం నిజంగా కీ.
CS50 లో, మరియు సాధారణంగా జీవితంలో, మీరు సాధారణంగా డౌన్ కూర్చుని కాదు,
మనస్సులో ఒక కార్యక్రమాన్ని కలిగి, మరియు రచన ప్రయత్నించండి ఒకేసారి మొత్తం తిట్టు విషయం.
>> ఇది అనివార్యంగా, విధంగా ఫలితమౌతుంది లోపాలతో మనకంటె మేమే ఇక్కడ చూసింది.
కూడా నేను, ఈ రోజు, నిరంతరం ఇతర తెలివితక్కువదని తప్పులు,
నిజానికి కష్టం తప్పులని గుర్తించడానికి కష్టం అని.
కానీ మీరు మరింత తప్పులు మరింత చేస్తుంది కోడ్ రేఖలు మీరు ఒకేసారి అన్ని వ్రాయండి.
మరియు అందువలన ఈ పద్ధతి కోడ్ యొక్క కొద్దిగా వ్రాయండి
మీరు సౌకర్యవంతంగా ఉన్నట్లు, కంపైల్ అది, దీన్ని అమలు సాధారణంగా దీనిని పరీక్షించడానికి,
అప్పుడు మేము ఉంచింది అందువలన కేవలం వంటి మొదలైనవి తరలించడానికి పొరలు మరియు గత వారం పొరలు
ఏదో నుండి భవనం చాలా మరింత క్లిష్టమైన ఏదో సాధారణ
ఇక్కడ కలగొచ్చు.
కూర్చో లేదు, మరియు ప్రయత్నించండి మొత్తం సమస్యను వ్రాయండి.
అసలైన ఈ బిడ్డ దశలను పడుతుంది.
>> ఇప్పుడు, తీగలను అన్ని కావు తమను చోటు ఉపయోగకరమైన.
మేము, వాస్తవానికి వంటి, ఆదర్శంగా ఇష్టం మా సంచిలో వేరే ఏదైనా కలిగి.
కాబట్టి యొక్క వాస్తవానికి ఖచ్చితంగా అలా వీలు.
>> నాకు ఇప్పుడు ముందుకు వెళ్లి అప్ రెచ్చిపోయినప్పుడు తెలియజేయండి కొంచెం వేరే కార్యక్రమం.
మేము పూర్ణాంక, ఈ int.c పిలుస్తాను.
నేను అదేవిధంగా వెళుతున్న CS550.h ఉన్నాయి.
నేను ప్రామాణిక IO ఉన్నాయి వెళుతున్న.
మరియు ఆ అందంగా సాధారణ చేస్తాడు తరగతి యొక్క ఈ మొదటి కొన్ని రోజుల్లో.
>> నేను సిద్ధంగా వెళుతున్న ఒక ప్రధాన విధి తో నాకు.
ఇప్పుడు బదులుగా స్ట్రింగ్ పొందడానికి, యొక్క ముందుకు వెళ్లి ఒక Int పొందుటకు వీలు.
యొక్క నేను కాల్ లెట్, మరియు అది పొందడానికి కాల్ Int, సన్నిహిత parens, సెమీ కోలన్.
ఇప్పుడు యొక్క తెలియజేసేలా దానితో ఏదో, printf.
>> యొక్క అలాంటిదే అని పిలవబడు హలో, బాక్ స్లాష్ n, కామా నేను.
నేను గొప్పది అనే వెబ్ నేను కేవలం ఒక క్షణం క్రితం ఏమి.
నేను ఇక్కడ ఒక ప్లేస్హోల్డర్ కలిగి.
నేను కావలసిన ఎందుకంటే, ఇక్కడ నేను కామాతో కలిగి ఆ ప్లేస్హోల్డర్ లోకి నేను ప్రదర్శించాడు.
>> కాబట్టి యొక్క ముందుకు వెళ్లి ప్రయత్నించండి తెలపండి ఈ కార్యక్రమం కంపైల్.
ఫైలు int.c. అంటారు
కాబట్టి నేను ఎంటర్ పూర్ణాంకానికి చేయడానికి, చెప్పటానికి వెళుతున్న.
ఓహ్ మై గాడ్, కానీ పెద్ద ఒప్పందం, కుడి?
ఒక తప్పు ఉంది.
>> ఒక వాక్యనిర్మాణ తప్పు ఉంది ఇక్కడ అలాంటి కార్యక్రమం కాదు
int.c, లైన్ లోపల సంగ్రహించబడిన ఏడు, పాత్ర 27, ఆకృతిలో లోపం
రకం చార్ నిర్దేశిస్తుంది సంసార, స్టార్.
కానీ వాదన రకం Int ఉంది.
>> కాబట్టి ఇక్కడ కూడా, మేము వెళుతున్నాం వెళ్ళడం లేదు చేస్తున్నాం అయినప్పటికీ నేటి పదార్థం చాలా ఉంది,
మేము మీకు హతమార్చడానికి చూడాలని ఖచ్చితంగా సి యొక్క ప్రతీ లక్షణాన్ని,
మరియు సాధారణంగా, ప్రోగ్రామింగ్ కేవలం ఈ మొదటి కొన్ని వారాల్లో.
కాబట్టి తరచుగా చేస్తాడు పరిభాషలో ఇది మీకు తెలియకపోతే.
మరియు, నిజానికి, చార్ స్టార్ విషయం మేము తిరిగి వచ్చి చూడాలని
ఒక వారం లేదా రెండు యొక్క సమయం లో.
>> కానీ ఇప్పుడు కోసం, చూడండి మేము ఉంటే తెలపండి తెలిసిన పదాలు అన్వయించడం.
Formats-- కాబట్టి మేము ఫార్మాట్ విని నిర్దేశకాన్ని ఫార్మాట్ కోడ్ ముందు.
ఆ తెలిసిన.
రకాన్ని కానీ వాదన రకం Int.
ఒక నిమిషం ఆగండి, నేను ఒక పూర్ణాంకానికి ఉంది.
>> బహుశా శాతం లు నిజానికి కొన్ని నిర్వచించిన అర్ధాన్ని కలిగి ఉంది.
మరియు, నిజానికి, అది.
పూర్ణాంకం, మీరు అనుకుంటే ఇది ప్రత్యామ్నాయంగా printf,
మీరు అసలైన ఉపయోగించాలి వివిధ ఫార్మాట్ స్పెసిఫయ్యర్.
మరియు మీరు ఈ తెలియదు తప్ప ఎవరైనా చెబితే,
నీకు ముందు చేసిన.
కానీ శాతం నేను ఏమిటి సాధారణంగా ఉపయోగించవచ్చు
పూర్ణాంకం లో పూరించే కోసం printf లో.
మీరు కూడా శాతం ఉపయోగించవచ్చు ఒక దశాంశ పూర్ణాంక d.
కానీ నేను ఇక్కడ nice మరియు సులభం.
కాబట్టి మేము ఆ వెళ్తారో.
>> ఇప్పుడు నాకు ముందుకు వెళ్ళి తెలపండి తయారు తిరిగి Int, ఎంటర్.
అంటే, ఎటువంటి దోషాలు బావుంటుంది.
డాట్ స్లాష్ పూర్ణాంకానికి సరే, తప్పు వినియోగదారు అనుభవం, నేను చెప్పలేదు ఎందుకంటే
ఏం చేయాలి.
కానీ ఆ మంచిది.
నేను త్వరగా పట్టుకోవడంలో చేస్తున్నాను.
>> ఇప్పుడు నాకు ముందుకు వెళ్ళి తెలపండి డేవిడ్, సరే, Zamila, రాబ్ లో టైప్ చేయండి.
సరే, ఈ ఒక మంచి విషయమే.
ఈ సమయంలో, నేను ఒక ఫంక్షన్ ఉపయోగించి వెబ్ Int పొందండి అనే పజిల్ ముక్క.
మరియు దాన్ని మారుతుంది మరియు మేము చేస్తాము term-- దీన్ని తర్వాత చూడండి
CS50 సిబ్బంది అమలు చేసింది విధంగా స్ట్రింగ్ పొందండి
అది భౌతికంగా రెడీ మీరు ఒక స్ట్రింగ్ పొందండి.
>> ఇది Int పొందండి అమలు చేసింది విధంగా అది మాత్రమే అవుతుంది
మీరు ఒక పూర్ణాంకం పొందండి.
మరియు మీరు, మానవ, సహకారం లేకపోతే, అంతే
అక్షరాలా అన్నారు మళ్ళీ ప్రయత్నించండి చేయడాన్ని మళ్లీ పునఃప్రయత్నించాలా చెప్పుచున్నాను
అక్షరాలా వరకు అక్కడే కూర్చొని, మెలితిరిగిన మీరు కొన్ని మాయా సంఖ్యలో నిర్బంధించే,
50, హలో 50 వంటి.
>> లేదా మేము మళ్ళీ ఈ అమలు చేస్తే 42 రకం, హలో 42.
కాబట్టి Int ఫంక్షన్ ఆ పజిల్ ముక్క లోపలి
తగినంత తర్కం, తగినంత ఆలోచన, దొరుకుతుందని, ఒక పదం ఏమిటి?
మరియు ఒక నంబర్ ఏమిటి?
మాత్రమే అంగీకరించడం చివరికి, సంఖ్యలు.
>> కాబట్టి ఈ హాజరవుతారు అన్ని ఆ వ్యక్తీకరణ ఉంది.
ఇప్పటివరకు.
కాబట్టి, అవును, చివరిసారి మేము అందంగా త్వరగా వెళ్లి
అమలు గేమ్స్, మరియు అనిమేషన్, స్క్రాచ్ మరియు కళాత్మక రచనలు.
మరియు ఇక్కడ, మేము కంటెంట్ గురవుతున్నాయి హలో వరల్డ్, హలో 50 తో.
>> ఇది అన్ని ఆ స్ఫూర్తిగా కాదు.
మరియు, నిజానికి, ఈ మొదటి కొన్ని ఉదాహరణలు కొంత సమయం పడుతుంది
ఉత్సాహంగా రాంప్.
కానీ మేము మరింత ఉన్నాయి నిజానికి, ఇప్పుడు నియంత్రిస్తాయి.
మరియు మేము చేయబోతున్నామని చాలా త్వరగా పొరలు మొదలు
ఈ ప్రాథమిక ధాతువుల పైన.
>> కానీ మొదటి, యొక్క అర్థం తెలియజేయండి ఏమి పరిమితులు ఉన్నాయి.
నిజానికి, విషయాలు ఒకటి స్క్రాచ్ సులభంగా లేదు
చూస్తున్నప్పుడు మాకు తెలియజేసేలా నిజంగా హుడ్ కింద,
మరియు ఒక అర్థం కంప్యూటర్ చేయవచ్చు ఏమి, ఉంది,
మరియు దాని పరిమితులు ఏమిటి.
మరియు, నిజానికి, ఆ లేకపోవడం అవగాహన, సమర్థవంతంగా, దీర్ఘకాల
మా సొంత mistakes-- రచన దారితీస్తుంది దోషాలు, అసురక్షిత సాఫ్ట్వేర్ వ్రాయడం
కొన్ని విధంగా హ్యాక్ కావాలి.
>> కాబట్టి యొక్క వైపు కొన్ని దశలు తీసుకుందాం ఈ కొద్దిగా బాగా అర్ధం
యొక్క మార్గం చెప్పటానికి, క్రింది ఉదాహరణ.
నేను ముందుకు వెళ్లి అమలు వెళుతున్న కట్లపాము అనే కార్యక్రమం వాస్తవ శీఘ్ర.
ఇలా, కలిసి కొన్ని సంఖ్యలు జోడించడానికి అనుమతిస్తుంది.
నేను కొన్ని మూలల్లో కోడ్ వెళుతున్న ఇక్కడ, మరియు కేవలం కాపీ మరియు పేస్ట్
ఇక్కడ నేను, ముందు కాబట్టి మేము ముందుగానే వెళుతున్న పొందవచ్చు.
ఇప్పుడు నేను ప్రాధమిక ఆరంభాల పొందారు కట్లపాము అనే ప్రోగ్రాం.
>> యొక్క ముందుకు వెళ్లి మనం.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు సే, intx పూర్ణాంకానికి పొందుతారు పొందుతాడు.
మరియు మీరు ఏమి తెలుసు?
యొక్క ఒక మెరుగైన యూజర్ అనుభవాన్ని తయారు చేద్దాము.
>> కాబట్టి యొక్క కేవలం x మరియు సమర్థవంతంగా వీలు వినియోగదారును ప్రాంప్ట్ మాకు x ఇవ్వాలని.
ఆపై నాలో printf, ముందుకు వెళ్లి చెప్పే వీలు ఎలా y ఉంది, ఈ సమయం భావించిందని
వినియోగదారు నుండి రెండు విలువలు.
ఆపై యొక్క కేవలం ముందుకు వెళ్ళి తెలపండి సే, printf, x మరియు y యొక్క మొత్తం.
ఇప్పుడు నేను శాతం లు చేయాలనుకుంటున్నారా లేదు.
నేను శాతం నేను చేయాలనుకుంటున్నారా, బాక్ స్లాష్ n, మరియు తరువాత మొత్తం విలువ ప్లగ్.
>> కాబట్టి నేను ఈ చేయడం గురించి వెళ్ళవచ్చు?
నీకు తెలుసా?
నేను వేరియబుల్స్ ఎలా ఉపయోగించాలో తెలుసు.
నాకు కేవలం ఒక కొత్త, Int z డిక్లేర్ తెలియజేయండి.
>> నేను ఇక్కడ ఒక అంచనా పడుతుంది వెళుతున్న.
ఈ సమాన సంకేతాలు ఉన్నాయి ఉంటే భాష, బహుశా నేను, x ప్లస్ y చేయవచ్చు,
చాలా కాలం నా అంతం వంటి ఒక సెమీ కోలన్ తో ఆలోచన?
ఇప్పుడు నేను ఇక్కడ డౌన్ తిరిగి వెళ్ళడానికి z లో ప్రదర్శించాడు చేయవచ్చు, ఒక సెమీ కోలన్ ఈ ఆలోచన పూర్తి.
మరియు లెట్స్ ఈ, ఇప్పుడు చూద్దాం లైన్లు x యొక్క సన్నివేశాలు పూర్ణాంకానికి పొందుతారు ఉంది.
వై పూర్ణాంకానికి పొందుతారు ఉంది.
>> , X మరియు y జోడించడానికి విలువ నిల్వ z-- కాబట్టి, మళ్ళీ, సమాన సైన్ గుర్తు
సమానం కాదు.
ఇది కుడి నుండి కార్య కాదు.
మరియు యొక్క మొత్తం ఎత్తి ప్రింట్ తెలియజేయండి x మరియు y యొక్క, వాచ్యంగా z కాదు
కానీ z లోపల ఏమి.
కాబట్టి యొక్క కట్లపాము తయారు చేద్దాము - నైస్, ఎటువంటి పొరపాట్లు ఈ సమయంలో.
డాట్ స్లాష్ కట్లపాము, ఎంటర్, x 1 అని అన్నారు.
>> వై 2 అవతరిస్తుంది.
మరియు x మరియు y మొత్తం 3.
కాబట్టి అన్ని జరిమానా మరియు మంచి.
>> కాబట్టి మీరు ఆ గణిత ఊహించే ఈ వంటి ప్రోగ్రామ్ పనిచేయాలి.
కానీ మీరు ఏమి?
ఈ వేరియబుల్ లైన్ 12, కూడా అవసరం?
మీరు అలవాటు పొందడానికి అవసరం లేదు కేవలం వేరియబుల్స్ విషయాలు నిల్వ
కేవలం మీరు ఎందుకంటే.
మరియు, వాస్తవానికి, సాధారణంగా భావిస్తారు చెడు డిజైన్
మీరు ఒక వేరియబుల్ సృష్టిస్తున్నా, అని ఈ సందర్భంలో z, అది ఏదో నిల్వ,
వెంటనే అది ఉపయోగించి, కానీ మళ్ళీ ఎప్పుడూ.
ఎందుకు ఏదో ఒక పేరు ఇచ్చి z వంటి మీరు వాచ్యంగా అయితే
ఉపయోగించడానికి వెళ్ళడం విషయం ఒక్కసారి మాత్రమే, అందువలన
మీరు సృష్టించిన ఎక్కడ సామీప్య మొదటి స్థానంలో,
లైన్స్ ఆఫ్ కోడ్ పరంగా దగ్గరగా?
కాబట్టి మీరు ఏమి?
ఇది సి అందంగా సౌకర్యవంతమైన అని అవుతుంది.
నేను నిజానికి అనుకుంటే ఇక్కడ ప్లగ్-ఇన్ విలువలు,
నేను ఒక కొత్త వేరియబుల్ ప్రకటించాలని అవసరం లేదు.
నేను కేవలం ప్లగ్-ఇన్ కాలేదు x ప్లస్ వై, సి అర్థం ఎందుకంటే
గణితం, మరియు గణిత ఆపరేటర్లు.
>> కాబట్టి నేను కేవలం ఈ గణిత చేయండి, చెప్పగలను, x ప్లస్ y, సంసార ఆ విలువలు,
ఫలితంగా ప్లగ్ ఆ స్ట్రింగ్ లోకి పూర్ణాంక.
సో ఈ అయితే, కావచ్చు మాత్రమే ఒక లైన్ తక్కువ
మెరుగైన డిజైన్, మెరుగైన కార్యక్రమం, తక్కువ కోడ్, ఉంది ఎందుకంటే అందువలన
నాకు అర్థం తక్కువైతే అది.
మరియు అది కూడా కేవలం క్లీనర్, మేము లేదు అజమాయిషీ ఉంటుంది
కొత్త పదాలు పరిచయం, కొత్త చిహ్నాలు, z వంటి,
వారు నిజంగా పోయినప్పటికి ఒక ప్రయోజనం చాలా సర్వ్.
>> దురదృష్టవశాత్తు, గణిత కాదు అన్ని విశ్వసనీయ కొన్నిసార్లు.
యొక్క ముందుకు వెళ్లి మనం.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న ఇప్పుడు క్రింది వాటిని.
>> యొక్క printf, శాతం నేను, ప్లస్ శాతం తెలియజేసేలా నేను, శాతం నేను, బాక్ స్లాష్ n ఉండాలి.
నేను దీన్ని xyx ప్లస్ y చేయ బోతున్నాను.
సో నేను తిరగరాయాల్సి వెళుతున్న ఈ కొద్దిగా భిన్నంగా ఇక్కడ.
నాకు కేవలం ఒక శీఘ్ర తెలివి చెక్ తెలియజేసేలా.
మళ్ళీ, యొక్క ముందుకు మనలోని లేదు వీలు.
కట్లపాము, డాట్ స్లాష్ కట్లపాము చేయండి.
x 1, y, 2, 1 ప్లస్ 2. 3.
కాబట్టి ఆ బావుంటుంది.
కానీ ఇప్పుడు క్లిష్టతరం వీలు ఒక బిట్, ఒక కొత్త ఫైలు సృష్టించవచ్చు.
>> నేను ఈ ఒక కాల్ వెళుతున్న, చెప్పటానికి ints, పూర్ణ బహువచనం.
నేను ఒక క్షణం క్రితం అక్కడ నాకు ప్రారంభిద్దాం.
కానీ ఇప్పుడు యొక్క కొన్ని ఇతర మార్గాల తెలియజేసేలా.
నాకు ముందుకు వెళ్లి ఈ క్రింది లెట్, printf, శాతం నేను, మైనస్ శాతం నేను,
శాతం నేను, కామా x, కామా yx మైనస్ y ఉంది.
నేను కొద్దిగా చేస్తున్నదాన్ని వివిధ గణిత.
మరో ఏమి చూద్దాం.
సో శాతం నేను సార్లు శాతం నేను శాతం నేను, బాక్ స్లాష్ n.
ప్లగ్-ఇన్ x, y మరియు, మరియు x సార్లు y లెట్.
మేము గుర్తుతో ఉపయోగిస్తాము సార్లు కోసం మీ కంప్యూటర్.
>> మీరు x వాడవద్దు. x అనేది ఇక్కడ ఒక వేరియబుల్ పేరు.
మీరు గుణకారానికి స్టార్ ఉపయోగించవచ్చు.
యొక్క ఒక మరింత తెలియజేసేలా.
Printf శాతం వృద్ధిరేటు విభజించబడి శాతం నేను ద్వారా, శాతం i ఉంది,
బాక్ స్లాష్ n. xy Y ఉంటే ద్వారా విభజించబడింది కాబట్టి మీరు C లో ముందుకు స్లాష్ ఉపయోగించడానికి
విభజన చేయాలని.
మరొకరిపై ఏమి చూద్దాం.
శాతం నేను యొక్క మిగిలిన మొత్తం, విభజించబడింది శాతం నేను ద్వారా, శాతం i ఉంది.
xy-- మరియు ఇప్పుడు మిగిలిన వదిలి లో ఏమి ఉంది.
మీరు ఒక విభజన ప్రయత్నించండి ఒక లవం లోకి హారం
ఎంత పైగా వదిలి మీరు తిరగడానికి కాదు?
>> సో అక్కడ, నిజంగా కాదు తప్పనిసరిగా చిహ్నంగా
మేము ఈ కోసం గ్రేడ్ పాఠశాల లో ఉపయోగించిన.
కానీ అక్కడ మీరు C. లో చెయ్యవచ్చు చెప్పటానికి x మాడ్యులో y, పేరు
ఈ సందర్భం లో ఈ శాతం సైన్ తికమక మీరు లోపల ఉన్నప్పుడు
డబుల్ కోట్స్, printf యొక్క, శాతం లోపల
ఫార్మాట్ స్పెసిఫయ్యర్ ఉపయోగిస్తారు.
>> మీరు బయట శాతం ఉపయోగించినప్పుడు ఒక గణిత వ్యక్తీకరణ లో,
ఇది మాడ్యులర్ కోసం మాడ్యులో ఆపరేటర్లు వార్తలు మా ప్రయోజనాల కోసం అంక
ఇక్కడ, కేవలం అర్థం, ఏమిటి x మిగిలిన Y ద్వారా విభజించబడింది?
కాబట్టి x Y ద్వారా విభజించబడింది x స్లాష్ y ఉంది.
Y ద్వారా విభజించబడింది x మిగిలిన ఏమిటి?
ఒక ప్రోగ్రామర్ గా చెప్పగలను ఇది mod y, x వార్తలు.
>> నేను ఇక్కడ ఎటువంటి పొరపాట్లు చేసిన ఉంటే, నాకు తెలియజేయండి ముందుకు వెళ్ళి, ints, బహువచనం, nice తయారు,
మరియు డాట్ స్లాష్ ints.
మరియు యొక్క ముందుకు వెళ్లి అలా, అనుకుందాము, 1, 10 వీలు.
అన్ని కుడి, 1 ప్లస్ 10 11, చెక్.
1 మైనస్ 10 తనిఖీ, ప్రతికూల 9 ఉంటుంది.
>> 1 సార్లు 10 10, చెక్.
1 10 మాదిరిగా ద్వారా విభజించబడింది సరే, మేము ఒక skip చేస్తాము.
10 ద్వారా విభజించబడింది 1 యొక్క మిగిలిన 1 ఉంది.
అది ఒప్పు.
కానీ ఇక్కడ ఒక బగ్ ఉంది.
>> ఒకనాటి నేను చాలు నా సరిచేయకుండా అందచేయాలని.
నేను 0 దగ్గరగా ఉద్దేశ్యం.
1 10 ద్వారా విభజించబడింది మీరు తెలిసిన మేము అయితే కొన్ని మూలల్లో కత్తిరించి, ఖచ్చితంగా, అది సున్నా.
కానీ అది నిజంగా ఉండాలి 1/10, 0.1, లేదా 0.10 0,1000, లేదా మొదలగునవి.
>> ఇది నిజంగా సున్నా ఉండకూడదు.
సరే, కంప్యూటర్ హాజరవుతారు అక్షరాలా చేయడం మనం దానిని చెప్పారు.
మేము Y ద్వారా విభజించబడింది x వంటి గణిత చేస్తున్నారు.
మరియు పంక్తులు శాతం x మరియు y రెండు, కోడ్ యొక్క ముందు, పూర్ణాంకాలు.
>> అంతేకాక, లైన్ 15 న, మేము చెప్పడం printf, హే, printf ప్లగ్-ఇన్
పూర్ణాంకం, ప్లగ్-ఇన్ పూర్ణాంకం, ప్లగ్-ఇన్ పూర్ణాంకం ప్రత్యేకంగా
x, మరియు తరువాత Y, అప్పుడు x Y ద్వారా విభజించబడింది. x మరియు y, ints ఉన్నాయి.
మేము అక్కడ మధురంగా.
>> కానీ ఏమి x x ద్వారా విభజించబడింది?
x ద్వారా y ఉండాలి విభజించబడింది, గణితశాస్త్ర, 1/10, లేదా 0.1,
ఇది ఒక వాస్తవ సంఖ్య ఒక వాస్తవ సంఖ్య కలిగి సమర్థవంతంగా, ఒక దశాంశ బిందువు.
అది ఒక పూర్ణాంకం కాదు.
>> కానీ సన్నిహిత ఏమిటి 1/10 లేదా 0.1 పూర్ణాంక?
అవును, అది రకమైన సున్నా.
0.1 ఈ చాలా వంటిది.
మరియు 1 ఈ చాలా ఉంది.
కాబట్టి 1/10 దగ్గరగా ఉంటుంది 0 అది ఒక కంటే.
>> కాబట్టి సి us-- కోసం చేస్తున్నది మేము అది ఆలోచన చెప్పారు ఎందుకంటే రకమైన
ఆ పూర్ణాంక తగ్గిస్తోంది ఉంది.
ఇది మళ్ళీ ఇది విలువ, తీసుకొని 0,1000 వంటి ఏదో రావలసిన,
0 మొదలగునవి.
ప్రతిదాని గురించి తగ్గిస్తోంది లో దశాంశ బిందువు తర్వాత
కనుక ఈ అన్ని విషయాన్ని అది లేదు ఎందుకంటే,
ఒక పూర్ణ సంఖ్య యొక్క భావన అధిగమించడంలో, ఇది ప్రతికూల 1, 0, 1 వంటి, కేవలం ఒక సంఖ్య ఉంది
అప్ మరియు డౌన్, ప్రతిదీ దూరంగా విసురుతాడు మీరు ఎందుకంటే దశాంశ బిందువు తర్వాత
ఒక దశాంశ బిందువు సరిపోవు నిర్వచనం ద్వారా పూర్ణాంకం లో.
>> కాబట్టి సమాధానం ఇక్కడ సున్నా.
సో ఎలా మేము ఈ పరిష్కరించాలి?
మేము అన్ని కలిసి మరొక పరిష్కారం అవసరం.
మరియు మేము ఈ క్రింది మనము అలా చేయవచ్చు.
>> నాకు ముందుకు వెళ్లి ఒక కొత్త సృష్టించడానికి ఫైలు, ఈ ఒక floats.c అని.
మరియు ఇక్కడ సేవ్ అదే డైరెక్టరీ float.c.
మరియు నాకు ముందుకు వెళ్లి కాపీ వీలు అంతకు ముందు కోడ్ కొన్ని.
>> కానీ బదులుగా పొందడానికి ఒక Int, దీన్ని చూద్దాం.
నాకు ఒక ఫ్లోటింగ్ పాయింట్ విలువ ఇవ్వండి x అనే. ఇక్కడ ఒక ఫ్లోటింగ్ పాయింట్
విలువ కేవలం వాచ్యంగా ఉంది ఒక ఫ్లోటింగ్ పాయింట్ ఏదో.
ఇది కుడి, ఎడమ తరలించవచ్చు.
ఇది ఒక వాస్తవ సంఖ్య వార్తలు.
>> మరియు నాకు ప్రార్థిం వీలు పూర్ణాంకానికి పొందుతారు కాని ఫ్లోట్ పొందుటకు,
ఇది కూడా మెను మధ్య ఉంది C250 లైబ్రరీ లో ఎంపికలు.
ఒక ఫ్లోట్ y మార్చడానికి లెట్.
కాబట్టి ఈ ఫ్లోట్ పొందుటకు అవుతుంది.
>> ఇప్పుడు, మేము ints ప్లగ్ వద్దు.
ఇది మేము శాతం ఉపయోగించాలి అవుతుంది ఫ్లోట్ f, ఫ్లోట్ శాతం f,
మరియు ఇప్పుడు అది సేవ్.
మరియు ఇప్పుడు, వేళ్లు దాటింది, తయారు తేలటం, నైస్, డాట్ స్లాష్ తేలియాడే.
x వన్ 1. వై అవతరిస్తుంది మళ్ళీ 10 అవతరిస్తుంది.
>> మరియు, నైస్, సరే నా జోడింపు సరైనది.
నేను, మరింత ఆశిస్తూ కానీ నేను రాయడం మర్చిపోయారు.
కాబట్టి యొక్క వెళ్ళి ఈ తార్కిక లోపం పరిష్కరించడానికి అనుమతిస్తాయి.
>> యొక్క ముందుకు వెళ్లి ఈ క్రింది పట్టుకోడానికి లెట్.
మేము కేవలం ఒక చిన్న కాపీ మరియు పేస్ట్ చేస్తాను.
నేను మైనస్ అంటున్నారు వెళుతున్న.
>> నేను సార్లు చెప్పడానికి వెళుతున్న.
నేను చెప్పే విభజించబడింది వెళుతున్న.
నేను, మాడ్యులో చేయబోవడం లేదు ఇది సంబంధించి ఇక్కడ కాదు
సార్లు ప్లస్ f ద్వారా విభజించబడింది, మరియు సరే, మళ్ళీ తెలియజేసేలా.
>> తేలటం చేయండి, డాట్ స్లాష్ తేలటం, మరియు 1, 10, and-- నైస్, ఏ, సరే.
కాబట్టి నేను ఒక ఇడియట్ రెడీ.
కాబట్టి ఈ చాలా సాధారణం కంప్యూటర్ సైన్స్ లో
ఈ వంటి తెలివితక్కువదని తప్పులు చేయడానికి.
>> బోధనకు ప్రయోజనాల కోసం, నేను నిజంగా చేయాలనుకున్నాము
ఇక్కడ శాస్త్రం మార్పు ప్లస్, మైనస్, టైమ్స్,
మరియు ఆశాజనక మీరు, విభజించడానికి ఈ వ్యాయామం సమయంలో గమనించాము.
కాబట్టి ఇప్పుడు యొక్క ఈ తిరిగి సంకలనం తెలియజేయండి కార్యక్రమం, డాట్ స్లాష్ తేలటం లేదు.
>> మరియు మూడవ సారి, లెట్స్ అది నా అంచనాలను కలుస్తుంది ఉంటే చూడండి.
1, 10, ఎంటర్ సరే, అవును, 1.000, 10.000 విభజించగా 0,100000 ఉంది.
మరియు అది మేము నియంత్రించవచ్చు అవుతుంది ఎన్ని సంఖ్యలు ఆ దశాంశ పాయింట్లు తర్వాత ఉన్నాయి.
మేము నిజానికి రెడీ.
మేము ఆ వచ్చి చేస్తాము.
>> కానీ ఇప్పుడు, నిజానికి, గణిత సరైనది.
సో, మళ్ళీ, ఏ తాత్కాలిక ఇక్కడ ఏముంది?
ఇది సి లో ఉన్నాయి హాజరవుతారు మాత్రమే కేవలం strings-- మరియు నిజానికి,
అక్కడ నిజంగా కాదు మేము ఎందుకంటే CS50 లైబ్రరీ తో ఆ జోడించండి.
కానీ కేవలం ints కాదు.
>> కూడా తేలియాడే ఉన్నాయి.
మరియు అది ఇతర డేటా కొంత అవుతుంది రకాలు బాగా, మేము దీర్ఘ ముందు ఉపయోగిస్తాము.
మీరు ఒకే అనుకుంటే అవుతుంది పాత్ర, ఒక పాత్రల స్ట్రింగ్,
మీరు ఒక చార్ ఉపయోగించవచ్చు.
>> మీరు ఒక bool అనుకుంటే ఆ అవుతుంది, ఒక బూలియన్ విలువ నిజమైన లేదా తప్పుడు మాత్రమే,
CS50 లైబ్రరీ ధన్యవాదాలు, మేము చేసిన అలాగే సి bool డేటా రకం జోడించారు.
కానీ అది కూడా ప్రస్తుతం అనేక ఇతర భాషలు అలాగే.
మరియు అది కొన్నిసార్లు మీరు అవుతుంది పెద్ద సంఖ్యలను అప్పుడు డిఫాల్ట్ దొరకడం అవసరం
ints మరియు తేలటం.
>> మరియు, వాస్తవానికి, ఒక డబుల్ ఒక సంఖ్య కాదు 32 బిట్స్ కానీ 64 బిట్స్ ఉపయోగిస్తుంది.
మరియు ఒక దీర్ఘ కాలం ఒక సంఖ్య అని కాదు 32, బిట్స్ కానీ 64 బిట్లను ఉపయోగిస్తున్నట్లయితే
వరుసగా, ఫ్లోటింగ్ పాయింట్ కోసం విలువలు మరియు పూర్ణ, వరుసగా.
కాబట్టి ఇప్పుడు నిజానికి చేసుకుందాం చర్య లో ఈ చూడండి.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు మరొక కార్యక్రమం అప్ విప్.
ఇక్కడ, నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు cs50.h. ఉన్నాయి లేదు
మరియు నాకు వీడలేదు, ప్రామాణిక io.h. ఉన్నాయి
>> మరియు మీరు ఏదో గమనించవచ్చు అల్లరిగా ఇక్కడ జరుగుతున్న.
అది విషయాలు కోడింగ్ రంగు కాదు అదే విధంగా అది ముందు చేసిన విధంగా.
మరియు ఆ నేను ఎందుకంటే, అవుతుంది విషయం ఒక ఫైల్ పేరు ఇచ్చిన లేదు.
>> నేను ఈ ఒక కాల్ వెళుతున్న sizeof.c మరియు హిట్ సేవ్.
మరియు నా చాలా నిర్మాణము ఏమి గమనిస్తారు ఆ నల్ల నేపథ్యానికి వ్యతిరేకంగా తెలుపు కోడ్.
ఇప్పుడు, కనీసం ఉంది కొందరు వంగపండు.
మరియు అది వాక్యనిర్మాణం హైలైట్.
>> ఎందుకంటే, చాలా సరళంగా, నేను చేసిన ఆ వార్తలు IDE ఏ రకమైన ఫైల్ చెప్పారు
అది ఒక పేరు ఇవ్వడం ద్వారా, మరియు ప్రత్యేకంగా ఒక ఫైల్ పొడిగింపు.
ఇప్పుడు, యొక్క ముందుకు వెళ్లి మనం.
నేను ముందుకు మరియు చాలా వెళ్ళి వెళుతున్న కేవలం కింది bool ప్రింట్
శాతం LU ఉంది.
>> మేము తిరిగి వచ్చి ఉంటుంది కేవలం ఒక క్షణం లో ఆ.
ఆపై నేను వెళుతున్న bool యొక్క ముద్రణ పరిమాణం.
ఇప్పుడు, కేవలం సేవ్ నాకు కొంత సమయం, నేను ఉన్నాను
మొత్తం చేయబోవడం ఒకేసారి ఈ యొక్క ఒక సమూహం.
మరియు, ప్రత్యేకంగా, నేను వెళుతున్న ఒక చార్ మరియు చార్ కు మార్చవచ్చు.
ఈ ఒక, నేను మార్చడానికి వెళుతున్న ఒక జంట మరియు డబుల్.
>> ఈ ఒక, నేను మార్చడానికి వెళుతున్న ఫ్లోట్ మరియు ఫ్లోట్.
ఈ ఒక, నేను వెళుతున్న ఒక Int మరియు ఒక పూర్ణాంకానికి మార్చడానికి.
మరియు ఈ ఒక, నేను వెళుతున్న ఒక లాంగ్ లాంగ్ మార్చడానికి.
మరియు అది ఇప్పటికీ తీసుకొని చాలా కాలం, లాంగ్ లాంగ్.
>> ఆపై, చివరకు, నేను ఇచ్చిన నాకు ఒక చాలా, స్ట్రింగ్.
ఇది సి లో, ఆ అవుతుంది అనే ప్రత్యేక ఆపరేటర్లు
ఆ పరిమాణం అక్షరాలా ఎప్పుడు అమలు అన్నారు
మనలో పరిమాణం చెప్పండి అంశాలపై ప్రతి.
మరియు ఈ ఇప్పుడు, ఒక మార్గం, మేము తిరిగి కనెక్ట్ చేయవచ్చు
గత వారం యొక్క చర్చను డేటా మరియు ప్రాతినిధ్య.
>> నాకు ముందుకు వెళ్లి కంపైల్ లెట్ డాట్ స్లాష్ పరిమాణం యొక్క పరిమాణం.
మరియు యొక్క చూసేలా.
అది సి లో ఆ మారుతుంది ప్రత్యేకంగా CS50 IDE న
ప్రత్యేకంగా ఆపరేటింగ్ సిస్టమ్ ఉబుంటు,
ఇది ఒక 64-bit ఆపరేటింగ్ ఉంది ఈ సందర్భంలో వ్యవస్థ,
ఒక bool అన్నారు స్థలం ఒక బైట్ ఉపయోగించండి.
ఆ పరిమాణంలో కొలుస్తారు ఎలా, కాదు బిట్స్, కానీ బైట్లు.
మరియు ఒక బైట్ ఎనిమిది బిట్స్ ఉంది గుర్తుచేసుకున్నారు.
కాబట్టి ఒక bool, అయినప్పటికీ మీరు సాంకేతికంగా మాత్రమే అవసరం ఒక 0 లేదా 1,
అది కొద్దిగా వృధా వార్తలు ఎలా మేము అది అమలు చేసిన.
ఇది నిజానికి ఒక మొత్తం ఉపయోగించడానికి జరగబోతోంది byte-- కాబట్టి అన్ని సున్నాలు, బహుశా
అన్ని వాటిని, లేదా అలాంటిదే, లేదా కేవలం ఒక 1 ఎనిమిది బిట్స్ మధ్య.
>> ఒక చార్, అదే సమయంలో, ఒక పాత్ర కోసం ఉపయోగించవచ్చు గత వారానికి ఒక ASCII పాత్ర వంటి,
ఒక్క అక్షరం అన్నారు.
మరియు ఆ మా తలంపుతో అప్ synchs ఇది కాకుండా మరింత 256 బిట్స్ ఏ ఉండటం,
అది ఏ ఉండటం తో synchs కంటే ఎక్కువ సమయం 8 బిట్స్ ఇది
మాకు చాలా 256 వంటి విలువలు ఇస్తుంది.
ఒక డబుల్ అన్నారు 8 బైట్లు లేదా 64 బిట్స్.
>> ఒక ఫ్లోట్ 4.
ఒక పూర్ణాంకానికి 4.
ఒక దీర్ఘ, దీర్ఘ 8.
మరియు ఒక స్ట్రింగ్ 8.
కానీ ఆ గురించి ఆందోళన లేదు.
మేము తిరిగి పొర పీల్ చూడాలని.
ఇది తీగలను చెయ్యవచ్చు హాజరవుతారు 8 బైట్ల కంటే ఎక్కువ ఉంటుంది.
>> మరియు, నిజానికి, మేము వ్రాయలేదు ఇప్పటికే తీగలను, హలో వరల్డ్
8 బైట్ల కంటే ఎక్కువ.
కానీ మేము తిరిగి వచ్చి ఉంటుంది కేవలం ఒక క్షణం లో ఆ.
కానీ దూరంగా ఇక్కడ టేక్ కింది ఉంది.
>> ఏ కంప్యూటర్ కేవలం పరిమిత ఉంది మెమరీ మరియు స్థలం మొత్తం.
మీరు చాలా నిల్వ చేయవచ్చు మీ Mac లేదా PC లో ఫైళ్లు.
మీరు కేవలం చాలా కార్యక్రమాలు నిల్వ చేయవచ్చు RAM, ఒకేసారి అమలు తప్పనిసరిగా కూడా
వర్చ్యువల్ మెమొరీ, ఎందుకంటే మీరు RAM ఒక పరిమిత మొత్తం కలిగి.
>> మరియు కేవలం ఉంటే picture-- వరకు మీరు ఒక లాప్టాప్ను తెరిచిన ఎప్పుడూ చేసిన
లేదా అదనపు మెమరీ ఆదేశించింది ఒక కంప్యూటర్ కోసం, మీరు
తెలియదు ఉండవచ్చు మీ కంప్యూటర్ లోపల
కనిపించే విషయం ఈ వంటి ఒక చిన్న.
కాబట్టి ఈ పేరుతో కేవలం ఒక సాధారణ సంస్థ కీలకమైన కంప్యూటర్లపై కోసం RAM చేస్తుంది.
మరియు RAM కార్యక్రమాలు ఉంది వారు అమలు చేస్తున్న సమయంలో నివసిస్తున్నారు.
>> కాబట్టి ప్రతి Mac లేదా PC, మీరు డబుల్ ఉన్నప్పుడు ఒక కార్యక్రమం క్లిక్ చేసి, అది తెరుచుకోవడంతో,
మరియు అది కొన్ని పద పత్రం తెరుచుకుంటుంది లేదా అలాంటిదే,
ఇది తాత్కాలికంగా నిల్వ రామ్ రామ్ వేగంగా ఎందుకంటే,
మీ హార్డ్ డిస్క్ కంటే, లేదా మీ ఘన రాష్ట్ర డిస్క్.
కార్యక్రమాలు వెళ్ళి పేరు కాబట్టి అది కేవలం వారు అమలు చేసినప్పుడు జీవించడానికి,
లేదా ఫైళ్ళను వాడుతున్నారు చేసినప్పుడు.
>> సో మీరు చూడండి విషయాలు మీ ల్యాప్టాప్ ఈ లోపల వంటి
లేదా కొద్దిగా పెద్ద విషయాలు మీ డెస్క్టాప్ లోపల.
కానీ కీ మీరు మాత్రమే ఒక కలిగి ఉంది ఈ విషయాలు పరిమిత సంఖ్య.
మరియు కేవలం పరిమిత పరిమాణంలో వార్తలు హార్డ్వేర్ ఈ బల్ల మీద కూర్చొని కుడి
ఇక్కడ.
>> కాబట్టి, తప్పనిసరిగా, మేము నిల్వ కాదు అనంతమైన పొడవు నంబర్లు.
మరియు, ఇంకా, మీరు తిరిగి తిరిగి అనుకుంటే గ్రేడ్ పాఠశాల, ఎన్ని అంకెలు చెయ్యవచ్చు
మీరు కుడి ఉన్నాయి ఒక దశాంశ బిందువుకు?
ఆ విషయమై, ఎన్ని అంకెలు చెయ్యవచ్చు మీరు ఒక దశాంశ బిందువుకు ఎడమ ఉందా?
రియల్లీ, అనంతం వరకు.
>> ఇప్పుడు, మనం మానవులు మాత్రమే ఉండవచ్చు మిలియన్ పలుకుతారు ఎలా తెలుసు,
బిలియన్, ట్రిలియన్, మరియు క్వాడ్రిలియన్, మరియు quintillion.
నేను పరిమితులను అధిగమించి చేస్తున్నాను నా understanding-- లేదా my-- నేను అర్థం
సంఖ్యలు, కానీ నా సంఖ్యల ఉచ్చారణ.
కానీ, అవి అపరిమిత భారీ పొందవచ్చు ఎడమ అనంతం వరకు అంకెలు
లేదా ఒక దశాంశ బిందువుకు కుడివైపున.
>> కానీ కంప్యూటర్లు మాత్రమే కలిగి మెమరీ పరిమిత మొత్తం,
ట్రాన్సిస్టర్లు పరిమిత సంఖ్య, ఒక లోపల కాంతి గడ్డలు పరిమిత సంఖ్య.
సో వాట్ జరుగుతుంది మీరు స్థలం రన్నవుట్?
ఇతర మాటలలో, మీరు ఉంటే గత వారం తిరిగి అనుకుంటున్నాను
మేము సంఖ్యలు గురించి మాట్లాడారు తాము బైనరీ ప్రాతినిధ్యం చేస్తున్నారు,
మేము పొందారు అనుకుందాం ఇక్కడ ఈ 8-బిట్ విలువ.
>> మరియు మేము ఏడు 1 యొక్క మరియు ఒక 0 కలిగి.
మరియు మేము కావలసిన అనుకుందాం ఈ విలువకు 1 జోడించండి.
ఈ ప్రస్తుతం ఒక నిజంగా పెద్ద సంఖ్య.
>> నేను గుర్తు ఉంటే ఈ, 254 ఉంది గత వారం కుడి నుండి గణిత.
కాని నేను ఏమి మార్చుకుంటే కుడివైపు 0 ఒక 1 ఆ?
మొత్తం సంఖ్య యొక్క కోర్సు, ఎనిమిది 1 యొక్క అవుతుంది.
కాబట్టి మేము ఇంకా మధురంగా.
>> మరియు ఆ బహుశా సూచిస్తుంది 255, అయితే సందర్భం బట్టి
నిజానికి ప్రాతినిధ్యం వహిస్తుంది ఒక ప్రతికూల సంఖ్య.
కానీ మరొక సమయం మరింత.
దాని గురించి మాదిరిగా ఈ భావం నేను వంటి వంటి హై.
>> ఇప్పుడు, కేవలం 8 బిట్స్ ఉంది.
మరియు నా Mac, తప్పనిసరిగా, మార్గం ఉంది మెమొరీ 8 కన్నా బిట్స్.
కానీ అది పరిమిత కలిగి లేదు.
కాబట్టి అదే వాదన వర్తిస్తుంది అయినా మేము తెరపై ఈ వాటిని ఎక్కువ.
>> కానీ మీరు ఉన్నాము ఏమవుతుంది ఈ సంఖ్య 255 నిల్వ,
మరియు మీరు 1 బిట్ అధిక లెక్కించడానికి అనుకుంటున్నారా?
మీరు 255 నుండి 256 కు వెళ్లాలని మీరు అనుకుంటున్నారా.
సమస్య, కోర్సు యొక్క, ఉంది మీరు బృందం సున్నా గత వారం వంటి వద్ద లెక్కింపు మొదలు,
మీరు అధిక లెక్కింపు సాధ్యం కాదు 256 గా ఒంటరిగా 257 వీలు,
ఒంటరిగా 258 వీలు ఎందుకంటే నేను మీరు ఒక 1 జతచేయునప్పుడు జరుగుతుంది?
మీరు పాత గ్రేడ్ పాఠశాల చేస్తే విధానం, మీరు ఇక్కడ ఒక 1 ఉంచండి,
ఆపై 1 ప్లస్ 1 2, కానీ ఆ నిజంగా ఒక సున్నా, మీరు 1 తీసుకు
1 తీసుకు 1 పడ్డారు.
ఈ విషయాలు అన్ని, ఈ 1, సున్నా వెళ్ళండి.
మరియు మీరు అవును, గాలి ఎవరైనా ఎడమ చేతి వైపు, ఎత్తి చూపారు ఒక 1.
కానీ ప్రతిదీ మీరు నిజానికి చూడండి మరియు మెమరీలో సరిపోయే
కేవలం ఎనిమిది 0 యొక్క, చెప్పటానికి ఇది ఉంది కొన్ని పాయింట్ వద్ద మీరు ఉంటే, ఒక కంప్యూటర్,
తగినంత అధిక లెక్కింపు ప్రయత్నించారు, మీరు చుట్టూ అన్నారు, అది అనిపించవచ్చు,
సున్నా, లేదా మరింత ప్రతికూలంగా సంఖ్యలు సున్నా కంటే కూడా తక్కువ ఉన్నాయి.
>> మరియు మేము రకమైన ఈ చూడగలరు.
నాకు ముందుకు వెళ్లి వ్రాద్దాము ఇక్కడ నిజమైన శీఘ్ర కార్యక్రమం.
నాకు ముందుకు వెళ్లి వ్రాద్దాము ఫ్లో అనే ప్రోగ్రామ్.
CS50.h కూడా ఉన్నాయి ప్రామాణిక IO.h-- OH,
నేను నిజంగా నా సింటాక్స్ హైలైటింగ్ దూరమయ్యాడు.
కాబట్టి యొక్క overflow.c ఈ అపహసించిరి.
>> ఇప్పుడు Int ప్రధాన void-- చాలాకాలంపాటు మేము చేస్తాము
ఎందుకు వివరిస్తూ తిరిగి వచ్చి మేము Int ప్రధాన తప్ప రాయడం ఉంచండి.
కానీ ఇప్పుడు కోసం, యొక్క కేవలం తెలియజేసేలా మంజూరు కోసం అది తీసుకొని.
యొక్క నాకు ఒక పూర్ణాంకానికి ఇవ్వాలని లెట్, మరియు 0 దాన్ని ప్రారంభించడం.
>> లెట్ యొక్క అప్పుడు Int కోసం చెయ్యాలి సున్నా పొందండి నిజానికి, యొక్క ఒక అనంతమైన లూప్ తెలియజేసేలా
మరియు ఏమి చూడండి.
నిజమైన అయితే, అప్పుడు యొక్క n ముద్రించాలా శాతం ఉంది నేను, బాక్ స్లాష్ n, ప్లగ్-ఇన్ n.
కానీ, ఇప్పుడు, యొక్క n గెట్స్ n ప్లస్ 1 తెలియజేసేలా.
>> కాబట్టి ఇతర మాటలలో, ప్రతి న ఈ అనంతమైన లూప్ ఏ మళ్ళా,
యొక్క n యొక్క విలువ తీసుకుందాం, దానికి 1 జోడించడానికి, ఆపై
n లో తిరిగి ఫలితాన్ని దాచలేకపొయాను ఎడమ.
మరియు, నిజానికి, మేము సింటాక్స్ చూసిన కొద్దిగా ఈ వంటి, క్లుప్తంగా.
ఒక చల్లని ట్రిక్ బదులుగా ఉంది అన్ని ఈ అవ్ట్ వ్రాసే,
మీరు నిజంగా ఒక n ప్లస్ 1 సమానం చెప్పగలను.
>> లేదా మీరు నిజంగా ఫాన్సీ ఉండాలనుకుంటున్నాను ఉంటే, మీరు చెప్పగలదు n ప్లస్ ప్లస్ సెమీ కోలన్.
కానీ ఈ చివరి రెండు కేవలం మేము కాల్ భావిస్తున్న ఏ వాక్యనిర్మాణ చక్కెర
మొదటి విషయం కోసం.
>> మొదటి విషయం మరింత స్పష్టమైన ఉంది, పూర్తిగా ఉత్తమంగా, పూర్తిగా సరిగ్గా.
కానీ ఈ ఎక్కువ సాధారణంగా ఉంది, నేను చెప్పటానికి చేస్తాము.
కాబట్టి మేము కేవలం ఒక క్షణం ఈ చేస్తాను.
>> వినిపిస్తుంది ఓవర్ఫ్లో ఇప్పుడు తయారు చేద్దాము, కాకుండా అరిష్ట, డాట్ స్లాష్ ఓవర్ఫ్లో.
యొక్క, n అందమైన పెద్ద సంతరించుకోనుంది లెట్.
కానీ యొక్క అనుకుంటున్నాను లెట్, ఎంత పెద్ద n పొందడానికి చేయవచ్చు?
>> n ఒక పూర్ణాంకానికి ఉంది.
మేము పరిమాణం తో ఒక క్షణం క్రితం చూసిన ఉదాహరణకు ఒక పూర్ణాంకానికి నాలుగు బైట్లు అని.
మేము గత వారం నుండి తెలుసు, నాలుగు బైట్లు 32 బిట్స్, ఎందుకంటే 8 సార్లు 4 32 ఉంది.
ఆ 4 బిలియన్ చేస్తాడు.
>> మరియు మేము 800,000 వరకు ఉన్నాయి.
ఈ ఎప్పటికీ పడుతుంది అన్నారు నేను బహుశా వీలయినంత ఎక్కువగా విశ్వాసం.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మీరు చాలాకాలంపాటు వాటిని వంటి,
మరియు స్పష్టముగా కంట్రోల్ సి హిట్, కంట్రోల్ సి, చాలా, ఇక్కడ కంట్రోల్ సి సాధారణంగా
అంటే రద్దు.
దురదృష్టవశాత్తు, ఈ ఎందుకంటే క్లౌడ్ లో రన్,
కొన్నిసార్లు క్లౌడ్ ఉంది చాలా stuff ఉమ్మివేస్తూ
చాలా అవుట్పుట్, అది జరగబోతోంది కొద్దిసేపట్లో నా ఇన్పుట్ చెందు
క్లౌడ్ చెయ్యడానికి.
కాబట్టి నేను హిట్ అయినప్పటికీ కంట్రోల్ సి కొన్ని సెకన్ల క్రితం
ఈ ఖచ్చితంగా వైపు ఒక అనంతమైన లూప్ యొక్క ప్రభావం.
>> కాబట్టి అలాంటి సందర్భాలలో, మేము ఉన్నాము అని వదిలి వెళ్ళడం.
మరియు మేము మరొక జోడించండి చూడాలని ఇక్కడ పైగా టెర్మినల్ విండో
కోర్సు యొక్క కాదు ఇది ప్లస్, తో ఆ వంటి, అది ఇప్పటికీ ఆలోచిస్తూ ఎందుకంటే.
యొక్క ముందుకు వెళ్లి ఉంచబడుతుంది కొంచెం సహేతుకమైన.
>> నేను ముందుకు వెళ్లి చేయ బోతున్నాను ఈ మాత్రమే పరిమిత పలు సార్లు.
, లూప్ ఒక ఉపయోగించడానికి అనుమతిస్తున్నట్లు ఇది నేను ముందుగా పేర్కొన్నట్లు.
దీన్ని యొక్క లెట్.
నాకు మరొక వేరియబుల్ పూర్ణాంకానికి నేను 0 ఇవ్వండి.
నేను కంటే, సే, 64 నేను ++ వీలు తక్కువగా ఉంటుంది.
ఇప్పుడు నాకు ముందుకు మరియు ముద్రణ వీడలేదు n బయటకు శాతం నేను ఉంది, కామా n.
ఆపై n-- ఈ ఇప్పటికీ ఎప్పటికీ తీసుకోవాలని చెప్పారు.
దీన్ని యొక్క లెట్.
>> n గెట్స్ n సార్లు 2.
లేదా మేము ఫాన్సీ కావచ్చు మరియు సార్లు 2 సమానం.
కానీ యొక్క కేవలం n పిలవబడు టైమ్స్ 2, స్వయంగా సమానం.
ఇతర మాటలలో, ఈ ప్రోగ్రామ్ యొక్క కొత్త వెర్షన్,
నేను ఎప్పటికీ వేచి వద్దు నుండి వంటి 800,000 4 బిలియన్.
యొక్క కేవలం ఈ పైగా పొందుటకు లెట్.
>> యొక్క నిజానికి రెట్టింపు n ప్రతి సమయం లెట్.
ఏ, రీకాల్, రెట్టింపు ఉంది కోర్సు యొక్క, కలిగి వ్యతిరేకం.
మరియు చివరి వారం అయితే మేము కలిగి మళ్ళీ ఏదో, మరియు మళ్ళీ,
మళ్ళీ, సూపర్ ఫాస్ట్, రెట్టింపు తప్పనిసరిగా అవుతుంది
1 నుండి అతిపెద్ద సాధ్యం మాకు పొందుటకు మేము ఒక పూర్ణాంకానికి తో విశ్వాసం విలువ.
>> కాబట్టి ఖచ్చితంగా దీన్ని చూద్దాం.
మరియు మేము దీర్ఘ ముందు ఈ తిరిగి వచ్చి చేస్తాము.
కానీ ఈ, మళ్ళీ, కేవలం వంటిది స్క్రాచ్ లో రిపీట్ బ్లాక్.
మరియు మీరు ముందు కాలం ఈ ఉపయోగిస్తాము.
>> ఈ కేవలం సున్నా నుండి లెక్కింపు అర్థం , కానీ 64, సమాన వరకు.
మరియు ఈ యొక్క ప్రతి పునరావృతం న లూప్, కేవలం నేను పెంచడం ఉంచడానికి.
నేను ++ - మరియు ఈ సాధారణంగా నిర్మాణం పై 7 కేవలం ఒక సూపర్ సాధారణ మార్గం
యొక్క కొన్ని పంక్తులు పునరావృతమైన కోడ్ సార్లు కొన్ని సంఖ్య.
ఏ లైన్స్ ఆఫ్ కోడ్?
ఈ కర్లీ జంట కలుపులు, మీరు ఇప్పుడు నుండి తీసుకోబడ్డాయి ఉండవచ్చు,
అంటే, క్రింది వాటిని.
>> ఉన్నప్పుడు ఇది వంటి స్క్రాచ్ లో, ఇది పసుపు బ్లాక్స్ ఉంది
మరియు ఇతర రంగులు ఆ రకమైన స్వీకరించటానికి లేదా ఇతర బ్లాక్స్ చుట్టుకొని.
ఆ ఏమి ఆ గిరజాల వార్తలు కలుపులు ఇక్కడ చేస్తున్న.
నేను నా వాక్యనిర్మాణం వస్తే మీరు కుడి సి అంటే క్యారట్ గుర్తు చూడగలరు
నేను ఉండేది ఎన్ని సార్లు ఈ సమస్యను పరిష్కరించడానికి ప్రయత్నిస్తున్న.
కాబట్టి యొక్క ఒక వదిలించుకోవటం తెలియజేయండి మొత్తంగా, మరియు ఆ విండోను మూసివేయండి.
మరియు మేము కొత్త ఉపయోగిస్తాము.
ఓవర్ఫ్లో, డాట్ స్లాష్ చేయండి ఓవర్ఫ్లో, Enter, అన్ని కుడి,
ఇది మొదటి వద్ద చెడు కనిపిస్తుంది.
కానీ యొక్క సమయంలో తిరిగి స్క్రోల్ అనుమతిస్తుంది నేను ఈ 64 సార్లు ఎందుకంటే.
>> మరియు మొదటి సారి గమనించి, N 1.
రెండవసారి, n 2, ఆపై 4, 8, 16.
మరియు అది వెంటనే తెలుస్తుంది నేను సుమారు 1 బిలియన్ ను,
నేను మళ్ళీ రెట్టింపు అయితే, ఆ నాకు 2 బిలియన్ ఇవ్వాలి.
కానీ అది అంతే, హాజరవుతారు దంతాగ్రం కుడి.
>> మరియు కనుక ఇది నిజానికి పొంగి 1 బిలియన్ నుండి ఒక Int
సుమారు ప్రతికూల 2 బిలియన్లు, పూర్ణాంకం ఎందుకంటే,
సంఖ్యలు మేము కాకుండా గత వారం భావించి,
అనుకూల మరియు ప్రతికూల స్పందనలు రెండూ కావచ్చు వాస్తవానికి మరియు ఒక కంప్యూటర్ లో.
మరియు వారిలో కాబట్టి కనీసం ఒక బిట్స్ సమర్థవంతంగా దొంగిలిస్తుంది.
కాబట్టి మేము నిజంగా కేవలం 31 బిట్స్, లేదా 2 బిలియన్ సాధ్యం విలువలు.
>> కానీ ఇప్పుడు కోసం, తాత్కాలిక చాలా ఉంది కేవలం సంసార ఈ సంఖ్యలు ఉన్నాయి
మరియు గణిత, సంసార చెడు ఏదో చివరికి ఏమవుతుంది
చివరికి మీరు ప్రయత్నిస్తున్న ఎందుకంటే బిట్స్ ఒక చాలా సార్లు permute.
మరియు మీరు సమర్థవంతంగా అన్ని నుండి వెళ్ళి 1 యొక్క బహుశా అన్ని 0, లేదా ఉండవచ్చు
ఇది కేవలం కొన్ని ఇతర నమూనా స్పష్టంగా, సందర్భమును బట్టి
ఒక ప్రతికూల సంఖ్య విధంగా అన్వయించవచ్చు.
అందువలన అది అత్యధిక నేను అగుపిస్తుంది ఈ ప్రత్యేక కార్యక్రమంలో పరిగణించవచ్చు
కేవలం సుమారుగా 1 బిలియన్లు ఉంది.
కానీ ఇక్కడ ఒక పాక్షిక పరిష్కారం ఉంది.
నీకు తెలుసా?
>> నాకు ఒక నుండి మార్చేద్దాం ఒక లాంగ్ లాంగ్ Int.
నాకు ఇక్కడ ముందుకు వెళ్లి మనం మరియు నేను కలిగి వెళుతున్న చెప్పడానికి
సంతకం లేని కాలం ఈ మార్చడానికి.
లేదా, నేను గుర్తుంచుకోవాలి ఎప్పుడూ, యొక్క చూసేలా.
>> యొక్క ముందుకు వెళ్లి ఓవర్ఫ్లో తయారు చేద్దాము.
వద్దు, అది కాదు, LLD, ధన్యవాదాలు.
కాబట్టి కొన్నిసార్లు గణగణమని ద్వని చేయు సహాయపడతాయి.
నేను ఏ రూపంలో గుర్తు లేదు స్పెసిఫైయర్ సుదీర్ఘ కాలం ఉంది.
>> కానీ, నిజానికి, గణగణమని ద్వని చేయు నాకు చెప్పారు.
గ్రీన్, మంచి రకమైన ఇప్పటికీ మీరు పొరపాటు అర్థం.
ఇది నేను LLD దీనర్ధం ఊహించడం ఉంది.
>> కాబట్టి నన్ను సలహా ఉంది పడుతుంది, సుదీర్ఘ వీలు దీర్ఘ దశాంశ సంఖ్య సేవ్.
మరియు డాట్ నాకు అది తిరిగి వీలు, , ఓవర్ఫ్లో స్లాష్ నమోదు చేయండి.
ఇప్పుడు చల్లని ఏమిటి ఈ ఉంది.
>> నేను సమయంలో తిరిగి స్క్రోల్ ఉంటే, మేము ఇప్పటికీ ప్రారంభం అదే place-- వద్ద లెక్కింపు 1, 2, 4,
8, 16.
నోటీసు, మేము పొందుటకు అన్ని మార్గం అప్ 1 బిలియన్.
కానీ అప్పుడు మేము సురక్షితంగా 2 బిలియన్ ను.
>> అప్పుడు మేము 4 బిలియన్ ను, తర్వాత 8 బిలియన్, 17 బిలియన్.
మరియు మేము అధిక వెళ్ళి, మరియు అధిక మరియు అధిక.
చివరికి, ఈ, చాలా, విరామాలు.
>> చివరికి, ఒక లాంగ్ లాంగ్ తో, ఇది 64-బిట్ విలువ, కాదు
ఒక 32-bit విలువ, మీరు కౌంట్ ఉంటే చాలా అధిక, మీరు చుట్టూ 0 వ్రాప్.
మరియు ఈ సందర్భంలో, మనం జరిగే ప్రతికూల సంఖ్య ముగిసేవి.
>> కాబట్టి ఈ ఒక సమస్య.
మరియు అది ఈ హాజరవుతారు సమస్య అన్ని మర్మమైన కాదు.
నేను ఉద్దేశపూర్వకంగా చేసిన అయినప్పటికీ ఈ తప్పులను తో ప్రేరేపిస్తుందని
అది మేము అన్ని రకమైన చూడండి అవుతుంది మాకు, లేదా మాకు కనీసం కొన్ని చుట్టూ చేయండి.
>> కాబట్టి లెగో స్టార్ వార్స్ లో, ఉంటే మీరు ఎప్పుడైనా గేమ్ ఆడలేదు,
అది మీరు చుట్టూ వెళ్ళే అవుతుంది LEGO ప్రపంచంలో విషయాలు అప్ బద్దలు,
మరియు తప్పనిసరిగా, నాణేలు సేకరించటం.
మరియు మీరు ఇంతవరకూ ఆడలేదు ఉంటే ఈ గేమ్ మార్గం చాలా సమయం,
ఈ పేరులేని వ్యక్తి ఇక్కడ, మొత్తం సంఖ్య
మీరు సేకరించిన ఆ నాణేలు అది అనిపించవచ్చు, 4 బిలియన్, ఉంది.
>> ఇప్పుడు, నిజానికి గుండ్రంగా ఉంది.
కాబట్టి LEGO ప్రయత్నిస్తున్నప్పుడు విషయాలు యూజర్ ఫ్రెండ్లీ ఉంచడానికి.
ఆ మేరకు ఖచ్చితంగా దీన్ని 2 చేయలేదు 32 అధికారం గత వారానికి.
కానీ 4 బిలియన్ కారణం.
ఈ సమాచారం ఆధారంగా కనిపిస్తుంది, ఆ LEGO, మరియు ఆ కంపెనీ
ఈ వాస్తవ సాఫ్ట్వేర్ తయారు నిర్ణయించుకుంది ఆ నాణేలు గరిష్ట సంఖ్య
యూజర్ కూడుతుంది , నిజానికి, 4 బిలియన్,
వారు వారి కోడ్ ఎంచుకున్నారు ఎందుకంటే స్పష్టంగా, దీర్ఘ కాలం ఉపయోగించడానికి,
కానీ కేవలం ఒక పూర్ణాంకం, సైన్ చేయని పూర్ణాంక, మాత్రమే సానుకూల దీని పూర్ణాంక,
మాక్స్ విలువ సుమారు ఉంది.
బాగా, ఇక్కడ మరొక హాస్య ఒకటి.
కాబట్టి ఆట నాగరికతలో, ఇది మీరు కొన్ని తెలిసిన కావచ్చు
ఇది సంవత్సరాల క్రితం హాజరవుతారు ఈ గేమ్ అనగా లో ఒక బగ్ ఉంది
మీరు పాత్ర పోషిస్తే ఆటలో మహాత్మా గాంధీ యొక్క,
బదులుగా అతనిని, చాలా కాముకుడు ఉండటం బదులుగా చాలా, చాలా ఉంది
దూకుడు, కొన్ని పరిస్థితులలో.
ముఖ్యంగా, మార్గం నాగరికత రచనలు అని మీరు ఉంటే, ఆటగాడు,
ప్రజాస్వామ్యం అవలంబిస్తుంది మీ దుడుకు స్కోరు గెట్స్
రెండు, కాబట్టి మైనస్ ద్వారా decremented మైనస్, మరియు అప్పుడు మైనస్ మైనస్.
>> కాబట్టి మీరు 2 వ్యవకలనం నుండి మీ వాస్తవ iterating.
దురదృష్టవశాత్తు, మీ iterating ఉంటే మొదట 1, మరియు మీరు 2 దాని నుండి వ్యవకలనం
ప్రజాస్వామ్యం స్వీకరించిన తరువాత ఇక్కడ ఉండవచ్చు మహాత్మా గాంధీ వంటి
అతను చాలా passive-- ఎందుకంటే, చేసిన 1 దుడుకు యొక్క స్థాయిలో.
కానీ ఆ తరువాత, ప్రజాస్వామ్యం స్వీకరించి ఉంటే అతను 1 నుండి ప్రతికూల 1 వెళ్తాడు.
>> దురదృష్టవశాత్తు, వారు సైన్ చేయని సంఖ్యలు ఉపయోగించి,
అంటే వారు కూడా ప్రతికూల చికిత్స అయితే ఈ సంఖ్యను వారు అభినందించారు.
మరియు ఆ అవుతుంది ప్రతికూల 1 సానుకూల సమానం,
విలక్షణమైన కంప్యూటర్ కార్యక్రమాలలో 255 ఉంది.
సో మహాత్మా గాంధీ స్వీకరించి ఉంటే ప్రజాస్వామ్యం, మరియు అందువలన
అతని మాటల దాడి స్కోరు తగ్గిందీ నిజానికి 255 చుట్టూ రోల్స్
మరియు అతనికి చాలా చేస్తుంది ఆటలో దూకుడు పాత్ర.
కాబట్టి మీరు ఈ లో Google చేయవచ్చు.
మరియు అది నిజానికి ఉంది, ఒక ప్రమాదవశాత్తు ప్రోగ్రామింగ్ దోషం
కానీ చాలా నమోదు చేసిన అప్పటి నుండి నమ్మకాలలో.
>> ఆ అన్ని ఆహ్లాదకరమైన మరియు అందమైన.
మరింత భయపెట్టే ఉన్నప్పుడు అసలు అంటే వాస్తవ ప్రపంచంలో పరికరాలు, మరియు గేమ్స్,
ఈ అదే దోషాలు ఉన్నాయి.
నిజానికి, కేవలం ఒక సంవత్సరం క్రితం ఒక వ్యాసం వచ్చింది బోయింగ్ 787 డ్రీమ్లైనర్ గురించి.
>> మరియు మొదటి వద్ద వ్యాసం గ్లాన్స్ ఒక చిన్న రహస్య చదువుతుంది.
కానీ అది చెప్పారు ఈ ఒక సాఫ్ట్వేర్ బోయింగ్ యొక్క బలహీనతని
నూతన 787 డ్రీమ్ లైనర్ జెట్ ఉంది పైలట్లు కలిగించే సామర్థ్యాన్ని
నియంత్రణ కోల్పోవడం విమానం, బహుశా
మధ్య విమానంలో, FAA అధికారులు ఇటీవల హెచ్చరించారు విమానయాన సంస్థలు.
ఇది నిర్ధారణ అయింది ఒక నమూనా 787
ఆధారిత చెయ్యబడింది అని విమానం నిరంతరం కోసం 248 రోజుల
అన్ని ఏకాంతర ప్రవాహంను కోల్పోతారు, ఎసి, జెనరేటర్ కారణంగా విద్యుత్ శక్తి
కంట్రోల్ యూనిట్లు, GCUs, ఒకేసారి వెళ్లడానికి సేఫ్ మోడ్ విఫలం.
ఇది నాకు కోల్పోయే ఉంటాము.
కానీ మెమో సరే, ఇప్పుడు నేను ఆ వచ్చింది చెప్పింది, పరిస్థితి ఒక సాఫ్ట్వేర్ సంభవించినట్లు
కు అంతర్గత ఎదుర్కోవడానికి జెనరేటర్ నియంత్రణ
తరువాత ఓవర్ఫ్లో అని యూనిట్లు నిరంతర అధికార 248 రోజులు.
మేము ఈ జారీ చేస్తారు నష్టాన్ని నిరోధించడానికి గమనించవచ్చు
అన్ని ఎసి విద్యుత్ కారణం కావచ్చు ఇది శక్తి,
విమానం యొక్క నియంత్రణ కోల్పోయేందుకు.
>> కాబట్టి, వాచ్యంగా, కొన్ని పూర్ణ సంఖ్య, లేదా కొన్ని సమానమైన డేటా రకం,
సాఫ్ట్వేర్ వాడుతూ ఒక వాస్తవ విమానం లో
మీరు మీ విమానంలో ఉంచుకుంటే ఆ ఇది స్పష్టంగా, దీర్ఘకాలం
మీరు కేవలం అమలు చేస్తున్నారు సందర్భంలో ఉంటుంది వాటిని నిరంతరం మరియు ఎప్పుడూ పనుల
మీ విమానం, అది కనిపిస్తుంది, లేదా దాని బ్యాటరీలు చనిపోయే తెలియజేసినందుకు,
చివరికి కూడుట, మరియు, మరియు, మరియు అప్, మరియు, మరియు అప్.
>> మరియు, ప్రకృతి ద్వారా, ఒక మెమరీ పరిమిత మొత్తం
, ఓవర్ఫ్లో ఉంటుంది తిరిగి రోలింగ్ సున్నా లేదా కొన్ని ప్రతికూల విలువ,
ఇది ఒక వైపు ప్రభావం భయపెట్టే నిజమైన రియాలిటీ
విమానం అవసరం అని తిరిగి ప్రారంభిస్తామని, సమర్థవంతంగా,
లేదా, దారుణంగా పడిపోవచ్చు ఇది ఫ్లైస్.
సో సమస్యలు ఈ రకాల మాతో ఇప్పటికీ,
even-- ఈ 2015 వ్యాసం, అన్ని మరింత భయపెట్టే
మీరు తప్పనిసరిగా ఏమీ లేనప్పుడు అర్థం అభినందిస్తున్నాము, లేదా ముందుగా
కొన్ని రకాల లోపాలు.
>> కనుక ఇది ఇతర ఒక ఉంది అది మారుతుంది డేటా ప్రాతినిధ్యం గురించి చెడు విషయం.
ఇది కూడా తేలటం హాజరవుతారు రకం పొరపాట్లు యొక్క, తేలటం ఎందుకంటే, చాలా,
నేను ఉంటాయి ప్రతిపాదిత 32 బిట్స్ అవసరం, లేదా బహుశా 64 మీరు ఒక డబుల్ ఉపయోగిస్తే.
కానీ ఆ ఇప్పటికీ పరిమిత వార్తలు.
>> మరియు క్యాచ్ మీకు ఆ సంఖ్యలు అనంతమైన సంఖ్య చాలు
దశాంశ బిందువు తర్వాత, ఏ విధంగా మీరు ఉంది
అన్ని సాధ్యం ప్రాతినిధ్యం వహించగల మేము నేర్పించేవారు సంఖ్యలు
గ్రేడ్ పాఠశాల ప్రపంచంలో ఉండవచ్చు.
కంప్యూటర్, ముఖ్యంగా, ఉంది ఆ సంఖ్యల ఉపసమితి ఎంచుకోండి
ఖచ్చితంగా సూచించడానికి.
>> ఇప్పుడు, కంప్యూటర్ చెయ్యవచ్చు రౌండ్ కొద్దిగా బహుశా,
మరియు సుమారు స్టోర్ మిమ్మల్ని అనుమతిస్తుంది మీరు బహుశా మీరు ఉండవచ్చు ఏ సంఖ్య.
కానీ, మీరు ఉంటే కేవలం intuitively బిట్స్ పరిమిత సంఖ్యలో కలిగి,
మీరు మాత్రమే వాటిని permute చేయవచ్చు చాలా పరిమిత మార్గాల్లో.
సో మీరు బహుశా కాదు ఒక పరిమిత సంఖ్యలో ఉపయోగించవచ్చు
బిట్స్ విశేషాన్ని, సున్నాలు మరియు వాటిని క్రమాలు
అనంత ప్రాతినిధ్యం సంఖ్యల సంఖ్య,
కంప్యూటర్లను ఉండవచ్చని సూచిస్తుంది బాగా కొన్నిసార్లు మాకు అబద్ధం అని.
>> నిజానికి, దీన్ని చూద్దాం.
నాకు CS50 IDE లోకి వెళదాం.
నాకు ముందుకు వెళ్లి ఒక చిన్న కార్యక్రమం సృష్టించడానికి
అది చూపించడానికి, ఖచ్చితంగా చెప్పలేని అని కంప్యూటర్లు అస్పష్టమైన, నిజానికి, ఉన్నాయి.
>> మరియు నాకు ముందుకు వెళ్లి తో ప్రారంభిద్దాం యెదుటనుండి కోడ్ కొన్ని,
మరియు ఇప్పుడు కేవలం క్రింది వాటిని.
నాకు ముందుకు వెళ్లి printf, శాతం తెలియజేసేలా F, బాక్ స్లాష్ n, 1 10 ద్వారా విభజించబడింది.
ఇతర మాటలలో, యొక్క లోతైన లో ప్రవేశిస్తాడు తెలియజేయండి 1/10 వంటి 1 మరియు 10 ద్వారా విభజించబడింది.
ఖచ్చితంగా, ఒక కంప్యూటర్ 1/10 సూచిస్తాయి.
>> కాబట్టి యొక్క ముందుకు వెళ్లి ఖచ్చితంగా చెప్పలేని తయారు చేద్దాము.
చూద్దాం.
ఫార్మాట్ డబుల్ టైప్ నిర్దేశిస్తుంది.
కానీ వాదన రకం Int.
ఏం జరుగుతోంది?
>> ఓహ్, ఆసక్తికరమైన, కాబట్టి అది ఒక వార్తలు పాఠం యెదుటనుండి నేర్చుకున్నాడు.
నేను చెప్పడం నేను హే, కంప్యూటర్ షో నాకు శాతం f ఒక ఫ్లోట్.
కానీ నేను ఇవ్వడం చేస్తున్నాను 2 ints.
దాన్ని మారుతుంది కాబట్టి, నేను పరిష్కరిస్తాము రెండు మార్గాలు లో ఈ.
>> నేను లోకి 1.0 ఒక చెయ్యి, మరియు కాలేదు 10 లోకి 10.0, ఇవి ఆ, నిజానికి,
మార్చే ప్రభావాన్ని కలిగి floats-- వాటిని ఇప్పటికీ ఆశాజనక
అదే సంఖ్య.
ఏదో ఉంది బయటకు లేదా అది మారుతుంది మేము దీర్ఘ ముందు మళ్ళీ చూస్తారు.
మీరు సంఖ్యలు తారాగణం కాలేదు.
>> మీరు, ఈ parenthetical ఉపయోగించి వ్యక్తీకరణ, మీరు చెప్పగలదు
హే, కంప్యూటర్, ఈ పడుతుంది 10, నేను తెలుసు ఇది ఒక పూర్ణాంకానికి ఉంది.
కానీ, అది చికిత్స దయచేసి, అయితే ఇది ఒక ఫ్లోట్ కాదు.
కానీ ఈ అనవసరంగా క్లిష్టమైన అనిపిస్తుంది.
>> మా ప్రయోజనాల కోసం నేడు యొక్క కేవలం సాహిత్యపరంగా వీలు
అవి విలువలు ఫ్లోటింగ్ తయారు ఈ వంటి ఒక దశాంశ బిందువు, తో.
నాకు ముందుకు తెలియజేయండి మరియు గణగణమని, తయారు ఖచ్చితంగా చెప్పలేని, మంచి, డాట్ స్లాష్
ఖచ్చితంగా చెప్పలేని, ఎంటర్.
సరే, మేము మంచి చూస్తున్న.
>> 1, 10 ద్వారా విభజించబడింది నా ఇక్కడ Mac, నిజానికి 0.100000 ఉంది.
ఇప్పుడు, నేను అక్కడ గ్రేడ్ పాఠశాల లో బోధించాడు 0 అసంఖ్యాక ఉండాలి.
కాబట్టి కనీసం ప్రయత్నించండి తెలపండి ఆ కొన్ని చూడటానికి.
ఇది printf ఒక చిన్న అని అవుతుంది మేము ఉపయోగించి పరిష్కరించగలుగుతున్నాము కంటే ఫ్యాన్సియెర్స్ ఇప్పటికీ.
ఇది మీరు పేర్కొనాలి లేదు అవుతుంది కేవలం శాతం f, లేదా కేవలం శాతం నేను.
మీరు నిజంగా పేర్కొనవచ్చు ఇక్కడ కొన్ని నియంత్రణ ఎంపికలు.
>> ముఖ్యంగా, నేను వెళుతున్న చెప్పటానికి, హే, printf
నిజానికి నాకు 10 దశాంశ కోణాల్ని.
కనుక ఇది ఒక చిన్న అసహజ కనిపిస్తోంది.
కానీ మీరు శాతం చెబుతారు, డాట్, ఎన్ని సంఖ్యలు
మీరు తర్వాత చూడాలనుకుంటే దశాంశ బిందువు, మరియు అప్పుడు f
ఫ్లాట్, కేవలం ఆ ఎందుకంటే ఏమి డాక్యుమెంటేషన్ చెప్పారు.
నాకు ముందుకు వెళ్లి సేవ్ లెట్.
>> మరియు నేను పొందుతున్నాను, చాలా గమనించవచ్చు విషయాలు తిరిగి టైప్ అలసిపోతుంది.
సో నేను ఏర్పాటు చేస్తున్నాను మరియు డౌన్ ఇక్కడ నా కీలు బాణం.
నేను అప్ నొక్కిన ఉంచుకుంటే, మీరు ఆదేశాలను అన్ని చూడగలరు
నేను చేసిన, లేదా తప్పుగా చేసింది.
>> నేను ఇప్పుడు ముందుకు వెళ్ళడానికి వెళుతున్న మరియు నిజానికి స్పష్టంగా, ఆ ఉపయోగించండి.
ఖచ్చితంగా చెప్పలేని, డాట్ చేయండి కాబట్టి imprecision-- స్లాష్
నేను నేర్పడం ప్రారంభమైంది గ్రేడ్ పాఠశాల వెతుకుతుంది.
నేను 10 దశాంశ ప్రింట్ పోయినా నెలకొల్పే, నిజానికి, 0,10000 ఉంది.
కానీ మీరు ఏమి?
>> యొక్క కొద్దిగా అత్యాశ పొందుటకు లెట్.
, యొక్క, అనుకుందాము నాకు 55 చూపించు దశాంశ తరువాత చూపాడు.
యొక్క నిజంగా ఈ తీసుకుందాం ఒక స్పిన్ కోసం అవుట్ ప్రోగ్రామ్.
నాకు తయారు తో రీమేక్ లెట్ ఖచ్చితంగా చెప్పలేని, డాట్ స్లాష్, ఖచ్చితంగా చెప్పలేని.
>> మరియు ఇక్కడ మేము వెళ్ళి.
మీ చిన్ననాటి ఒక అబద్ధం ఉంది.
స్పష్టంగా, 1 10 ద్వారా విభజించబడింది నిజానికి 0.100000000000000005551115123--
>> ఏమి జరుగుతుంది?
సరే, మీరు రకమైన ఉంటే, అవుతుంది అంతర్లీన బయటకు దూరంగా చూడండి
ఈ ప్రాతినిధ్యం సంఖ్య, అది నిజానికి
కచ్చితంగా 1/10, లేదా 0.1 మరియు సున్నాలు అసంఖ్యాక.
ఇప్పుడు, ఎందుకు అని?
>> Well, ఈ ఒక సాధారణ అయినప్పటికీ మాకు మానవులు సంఖ్య 1, 10 ద్వారా విభజించబడింది
అది ఇప్పటికీ అనంతం వరకు ఒకటి సంఖ్యలు మేము అప్ అనుకుంటున్నాను అని.
కానీ ఒక కంప్యూటర్ మాత్రమే ప్రాతినిధ్యం వహించగల పరిమిత పలు కాబట్టి సంఖ్యలు.
అందువలన, సమర్థవంతంగా, ఏమి కంప్యూటర్ మాకు దాని సన్నిహిత ఉంది చూపిస్తూ
సంఖ్య అంచనాను మేము నమ్ముతున్నాము 1/10 ఉంది అనుకుంటున్నారా,
లేదా నిజంగా 0,10000 అనంతంలోకి.
>> అయితే, అయితే, ఈ అది పొందవచ్చు వంటి వాటితో వ్యవహరిస్తాయి.
మరియు, నిజానికి, మీరు చూడండి ఉంటే హుడ్ కింద,
మనం చూస్తూ ఇక్కడ ఉన్నారు అని దశాంశ తరువాత 55 అంకెలు,
మేము నిజంగా ఆ రియాలిటీ చూడండి.
ఇప్పుడు మీరు చేసిన జనాంతికంగా, ఉంటే ఎప్పుడైనా movie-- చూసిన
మీరు చాలా బహుశా haven't-- కానీ సూపర్మ్యాన్ 3 కొన్ని సంవత్సరాల క్రితం,
రిచర్డ్ ప్రయర్ తప్పనిసరిగా ఈ పరపతి తన కంపెనీ లో రియాలిటీ చాలా దొంగిలించడానికి
నాణేలు భిన్నాలు మరియు భిన్నాల, నేను గుర్తుకు వంటి company-- ఎందుకంటే
ఇది while-- తప్పనిసరిగా ఒక అయ్యింది సరిపోయే లేదు ఏదైనా దూరంగా విసిరి కాదు
సెంట్లు భావన.
>> కానీ మీరు అప్ జోడిస్తే ఈ చిన్న, చిన్న, చిన్న మళ్ళీ సంఖ్యలు,
మళ్ళీ, మళ్ళీ, మీరు వంటి చెయ్యవచ్చు, ఈ కేసులో డబ్బు మంచి మొత్తం తయారు.
>> అదే ఆలోచన ద్వారా ఆవిర్భవించినది జరిగినది మరింత ఇటీవల, అయితే ఇప్పుడు పాత
సినిమా, ఆఫీస్ స్పేస్ అని, అక్కడ ఆ సినిమాలో అబ్బాయిలు,
ఇదే చేశాడు, ఇది ఇరుక్కొనిపోయింది పూర్తిగా చాలా మార్గం తో ముగించారు
వారి బ్యాంకు ఖాతాలో డబ్బు.
ఇది అన్ని చాలా అనుమానాస్పద ఉంది.
కానీ రోజు చివరిలో, ఖచ్చితంగా చెప్పలేని అన్ని మా చుట్టూ ఉంది.
>> మరియు ఆ, చాలా, ఉంటుంది కేసు భయపెట్టే.
ఇది అవుతుంది సూపర్మ్యాన్ 3 మరియు ఆఫీస్ స్పేస్ పక్కన, అక్కడ
కొన్ని చాలా వాస్తవికంగా ఉంటాయి ప్రపంచ శాఖల
అస్పష్టమైన వాస్తవాలకు ఆఫ్ డేటా ప్రాతినిధ్యం
కూడా మన మానవులకు ఈ రోజు అవసరం లేదు
అలాగే మేము వంటి అర్థం, లేదా తరచూ మేము తప్పక గుర్తుంచుకోవాలి.
మరియు, నిజానికి, క్రింది క్లిప్లను కొన్ని వాస్తవ ప్రపంచ పరిశీలించి నుండి
మీరు ఏమవుతుంది శాఖల ఖచ్చితంగా చెప్పలేని అభినందిస్తున్నాము లేని
సంఖ్యలు ప్రాతినిధ్యం జరుగుతుంది.
>> [వీడియో ప్లేబ్యాక్]
>> -Computers, మేము అన్ని ఆమోదించడానికి వచ్చి తరచుగా నిరాశపరిచింది సమస్యలు
, వైరస్లు them-- దోషాలు తో వెళ్ళి, మరియు సాఫ్ట్వేర్ అవాంతరాలు,
చెల్లించడానికి చిన్న ధరలు కోసం సౌలభ్యం కోసం.
కానీ అధిక టెక్ మరియు అధిక వేగం సైనిక మరియు స్పేస్ ప్రోగ్రామ్ అప్లికేషన్లు,
చిన్న సమస్య చెయ్యవచ్చు సంక్షోభం వృద్ధి చేయబడుతుంది.
>> జూన్ 4 వ, 1996 న, శాస్త్రవేత్తలు తయారు ఒక మనిషి లేని Ariane 5 రాకెట్ లాంచ్.
ఇది శాస్త్రీయ మోస్తున్నాడు ఉపగ్రహాలు రూపొందించిన
ఖచ్చితంగా ఎలా స్థాపించడానికి భూమి యొక్క అయస్కాంత క్షేత్రం సంకర్షణ
సౌర గాలులు తో.
రాకెట్ కోసం నిర్మించారు యూరోపియన్ స్పేస్ ఏజెన్సీ,
మరియు దాని సౌకర్యం నుండి ప్రయోగించారు ఫ్రెంచ్ గయానా తీరంలో.
>> సుమారు 37 సెకన్లు -At విమాన, వారు మొదటి
గమనించి ఏదో తప్పు వెళుతున్న.
నాజిల్ లో swiveling ఉన్నాయి ఒక విధంగా వారు నిజంగా కాదు.
విమాన 40 సెకన్లు, స్పష్టంగా, వాహనం కష్టాలను ఎదుర్కొంది.
>> వారు చేసిన మరియు ఆ దానిని నాశనం చేయడానికి ఒక నిర్ణయం.
పరిధి భద్రతా అధికారి, తో విపరీతమైన దమ్మున్న బటన్ నొక్కినప్పుడు,
అది అనుకొనుట ముందు, రాకెట్ పేల్చి ప్రజా భద్రత ప్రమాదం మారింది.
>> -ఈ తొలి ఉంది Ariane 5 ప్రయాణం.
మరియు దాని విధ్వంసం పట్టింది ఎందుకంటే ఒక దోషం ఉంచండి
రాకెట్ యొక్క సాఫ్ట్వేర్ పొందుపరిచారు.
-Ariane న సమస్య ఉంది అనేక ఉంది ఆ
వ్యక్తపరచటానికి 64 బిట్స్ అవసరం.
మరియు వారు మార్పు కోరుకున్నారు ఒక 16-bit సంఖ్య.
వారు భావించారు సంఖ్య మాత్రం ఎప్పుడూ
చాలా పెద్ద వారిలో చాలా ఒక 64-బిట్ సంఖ్య అంకెలు సున్నాల ఉన్నాయి.
వారు తప్పు ఉన్నారు.
>> ఒకటి అసమర్థత అంగీకరించడానికి సాఫ్ట్వేర్ ప్రోగ్రామ్
సంఖ్య రకం ద్వారా ఉత్పత్తి మరో వైఫల్యం మూలంలో.
సాఫ్ట్వేర్ అభివృద్ధి మారింది చేసింది కొత్త టెక్నాలజీ చాలా ఖరీదైన భాగం.
Ariane రాకెట్ చాలా ఉన్నాయి విజయవంతమైన, ఎక్కువ సాఫ్ట్వేర్
అది కూడా ఉంది కోసం సృష్టించబడింది Ariane 5 ఉపయోగిస్తారు.
>> -ది ప్రాథమిక సమస్య Ariane ఉంది 5, వేగంగా వేగంగా పుంజుకుంది.
మరియు సాఫ్ట్వేర్ కాలేదు ఆ లెక్కలోకి.
>> రాకెట్ యొక్క -ది విధ్వంసం భారీ ఆర్థిక విపత్తు ఉంది
అన్ని వలన ఒక నిమిషం సాఫ్ట్వేర్ లోపం.
కానీ ఈ మొదటి కాదు సమయం డేటాను మార్పిడి సమస్యలు
ఆధునిక రాకెట్ సాంకేతిక చుట్టుముట్టాయి.
>> , ఇన్ 1991 ప్రారంభంలో మొదటి గల్ఫ్ యుద్ధం కారణంగా,
పాట్రియాట్ క్షిపణి ఇదే రకమైన అనుభవం
సంఖ్య మార్పిడి సమస్య.
మరియు ఫలితంగా, 28 మంది 28 అమెరికన్ సైనికులు,
మరణించారు, మరియు గురించి 100 ఇతరులు గాయపడ్డారు,
ఎప్పుడు, ఏ చేయాలో పాట్రియాట్, ఇన్కమింగ్ Scuds రక్షణగా,
ఒక క్షిపణి దాడి విఫలమైంది.
>> చేసినప్పుడు ఇరాక్ కువైట్, మరియు అమెరికా ఆక్రమించారు 1991 ఆరంభంలో డిసర్ట్ స్టార్మ్ ప్రారంభించింది,
పాట్రియాట్ క్షిపణి బ్యాటరీలు తరలించేవారు సౌదీ అరేబియా మరియు ఇజ్రాయెల్ రక్షించడానికి
ఇరాకీ వేగంగా ఎగిరిపోవు క్షిపణి దాడులు నుండి.
పాట్రియాట్ ఒక సంయుక్త మీడియం-పరిధి గాలి వ్యవస్థ ఉపరితల, తయారు
రేథియాన్ సంస్థ.
>> పాట్రియాట్ ఇంటర్సెప్టర్ -ది పరిమాణం కూడా సుమారు 20 అడుగుల పొడవుగా ఉంది.
మరియు దాని గురించి 2,000 పౌండ్ల బరువు ఉంటుంది.
మరియు దాని గురించి ఒక వార్హెడ్ చేరవేస్తుంది, నేను దాదాపు 150 పౌండ్ల నేను భావిస్తున్నాను.
మరియు వార్హెడ్ అనేది అధిక పేలుడు, ఇది
చుట్టూ శకలాలు ఉంది.
వార్హెడ్ కేసింగ్ ఉంది buckshot వంటి పని రూపొందించబడింది.
>> -ది క్షిపణులను నిర్వహిస్తున్నారు కంటైనర్ ప్రతి నాలుగు,
మరియు ఒక సెమీ ట్రైలర్ ద్వారా రవాణా చేస్తారు.
>> -ది పాట్రియాట్ వ్యతిరేక క్షిపణి వ్యవస్థ తిరిగి ఇప్పుడు కనీసం 20 సంవత్సరాల వెళ్తాడు.
ఇది మొదట్లో రూపకల్పన ఒక వాయు రక్షణ క్షిపణి
శత్రువు విమానాలు డౌన్ చిత్రీకరణకు.
మొదటి గల్ఫ్ యుద్ధం లో, ఆ యుద్ధం వెంట వచ్చిన,
ఆర్మీ దానిని ఉపయోగించడానికి కోరుకున్నారు Scuds, కాదు విమానాలు డౌన్ షూట్.
>> ఇరాకీ ఎయిర్ ఫోర్స్ చాలా సమస్య కాదు.
కానీ సైన్యం Scuds గురించి భయపడి జరిగినది.
అందువలన వారు ప్రయత్నించారు పాట్రియాట్ అప్గ్రేడ్.
>> ఒక శత్రువు -Intercepting క్షిపణి మాక్ 5 వద్ద ప్రయాణిస్తున్న
తగినంత సవాలు కానుంది.
కానీ ఉన్నప్పుడు పాట్రియాట్ లోకి తరలించారు,
సైన్యం యొక్క aware కాదు చేసిన ఇరాకీ మార్పు
వారి Scuds హిట్ దాదాపు అసాధ్యం.
>> దాన్ని జరిగిన Scuds అని వస్తున్న కారణంగా అస్థిర ఉన్నాయి.
వారు wobbling ఉన్నాయి.
ఈ కారణం ఉంది ఇరాకీలు క్రమంలో,
600 కిలోమీటర్ల పొందడానికి 300 కిలో బయటకు
శ్రేణి క్షిపణి, బరువు పట్టింది ముందు వార్హెడ్ బయటకు.
వారు వార్హెడ్ తేలికైన చేసిన.
>> కాబట్టి ఇప్పుడు పాట్రియాట్ ఉంది వేగంగా ఎగిరిపోవు వద్ద రావటానికి ప్రయత్నిస్తున్న.
మరియు ఎక్కువ సమయం, సమయం అధిక సంఖ్యలో
అది కేవలం వేగంగా ఎగిరిపోవు ద్వారా ఫ్లై.
పాట్రియాట్ వ్యవస్థ నిర్వాహకులు ఒకసారి పాట్రియాట్ దాని లక్ష్యం తప్పిన గ్రహించారు,
వారు పాట్రియాట్ వార్హెడ్ విస్ఫోటనం ఇది సాధ్యమైతే మరణాలు నివారించేందుకు
భూమి తగ్గుతుందని అనుమతి ఇచ్చారు.
>> ఎక్కువ మంది చూసిన -ఆ ఉంది, ఆకాశంలో ఆ పెద్ద ఫైర్బాల్స్,
మరియు తప్పుగా అర్ధం వేగంగా ఎగిరిపోవు వార్హెడ్లతో యొక్క అడ్డుకోవటాన్ని కలిగి ఉంటాయి.
>> రాత్రి -కానీ ఆకాశం, పేట్రియాట్స్ కనిపించింది
విజయవంతంగా దాహ్రాన్, Scuds నాశనం,
ఏ తప్పు ఉండవచ్చు దాని పనితీరు గురించి.
, ది పాట్రియాట్ యొక్క రాడార్ వ్యవస్థ ఇన్కమింగ్ వేగంగా ఎగిరిపోవు కోల్పోయిన ట్రాక్,
మరియు వలన ప్రారంభం కాలేదు ఒక సాఫ్ట్వేర్ దోషం.
ఇది మొదటి కనుగొన్న ఇజ్రాయిల్ ఉంది వ్యవస్థ ఇక ఆ
ఎక్కువ సమయం వ్యత్యాసం కారణంగా ఇమిడి గడియారం, మారింది
వ్యవస్థ యొక్క కంప్యూటర్ లో.
>> యునివర్సిటి గురించి రెండు వారాల ముందు లో Dhahran విషాదం,
ఇజ్రాయిల్ నివేదించబడింది రక్షణ శాఖ
ఆ వ్యవస్థ సమయం కోల్పోయింది.
ఎనిమిది గంటలు లేదా నడుస్తున్న తరువాత, వారు వ్యవస్థ గమనించి
గమనించదగిన తక్కువ ఖచ్చితమైన మారుతోంది జరిగినది.
రక్షణ శాఖ స్పందించింది పాట్రియాట్ బ్యాటరీలు అన్ని చెప్పడం
వ్యవస్థలు వదిలి లేదు ఒక కాలం లో.
వారు ఒక కాలం నేనెప్పుడూ was-- ఎనిమిది గంటల, 10 గంటల, 1,000 గంటల.
ఎవరూ తెలుసు.
>> -ది పాట్రియాట్ బ్యాటరీ శిబిరాలని వద్ద ఉంచబడ్డారు
Dhahran మరియు దాని దోషపూరిత అంతర్గత వద్ద క్లాక్ 100 గంటల పైగా ఉండేది
ఫిబ్రవరి 25 వ తేదీ రాత్రి.
>> -ఇది కచ్చితత్వంతో సమయం ట్రాక్ ఒక సెకనులో పదో గురించి.
ఇప్పుడు, ఒక సెకనులో పదో ఒక ఆసక్తికరమైన సంఖ్య,
ఇది వ్యక్తం సాధ్యం కాదు ఎందుకంటే సరిగ్గా బైనరీ, ఇది
అది ఖచ్చితంగా వ్యక్తం కాదు వంటిదని ఏ ఆధునిక డిజిటల్ కంప్యూటర్ లో.
ఇది నమ్మకం కష్టం.
>> కానీ ఒక ఉదాహరణగా ఈ ఉపయోగించండి.
ప్రధమ మూడవ తీసుకుందాం.
మూడవ వంతు ఉండకూడదు సరిగ్గా దశాంశ వ్యక్తం.
ఒక మూడవ 0,333 ఉంది అనంతం కోసం జరగబోతోంది.
>> ఆ చేయాలని మార్గమే ఉంది దశాంశ ఖచ్చితమైన ఖచ్చితత్వం.
ఆ సమస్య సరిగ్గా రకం వార్తలు ఆ పాట్రియాట్ లో జరిగింది.
ఇక సిస్టమ్ నడిచింది, దారుణంగా సమయంలో లోపం మారింది.
>> ఆపరేషన్ 100 గంటల -After, సమయం లో లోపం మాత్రమే గురించి ఒక మూడవ
రెండవ.
కానీ ఒక లక్ష్యంగా పరంగా క్షిపణి మాక్ 5 వద్ద ప్రయాణిస్తున్న,
అది ఒక ట్రాకింగ్ ఫలితంగా 600 మీటర్ల లోపం.
ఇది ఒక తీవ్రమైన దోషం ఉంటుంది ఏం సైనికులకు
జరిగిన ఒక వేగంగా ఎగిరిపోవు ప్రయోగ నిలిచింది ప్రారంభ హెచ్చరిక ఉపగ్రహాలు ద్వారా గుర్తించిన
మరియు వారు వేగంగా ఎగిరిపోవు అని తెలుసు వారి సాధారణ దిశలో వస్తున్న.
ఇది రాబోయే అక్కడ వారు తెలియదు.
>> -ఇది ఇప్పుడు రాడార్ వరకు ఉంది పాట్రియాట్ వ్యవస్థ భాగం
గుర్తించడం మరియు ఉంచడానికి దాహ్రాన్ డిఫెండింగ్ ఇన్కమింగ్ శత్రువు క్షిపణి యొక్క ట్రాక్.
>> -ది రాడార్ చాలా స్మార్ట్ ఉంది.
ఇది నిజానికి ట్రాక్ చేస్తుంది వేగంగా ఎగిరిపోవు స్థానం,
ఆపై అది ఎక్కడ బహుశా అంచనా తదుపరి సమయం రాడార్ పంపిస్తామని
ఒక అవ్ట్ పల్స్.
ఒక పరిధి గేట్ అని పిలిచేవారు.
>> -Then, పాట్రియాట్ ఒకసారి తగినంత సమయం ఉంది నిర్ణయించుకుంటుంది
తిరిగి వెళ్ళి తదుపరి తనిఖీ జారీ ఈ కనుగొనబడింది వస్తువు కోసం నగర,
ఇది తిరిగి వెళ్తాడు.
అది తప్పు తిరిగి వెళ్ళినప్పుడు స్థలం, ఇది ఆ వస్తువు చూస్తాడు.
మరియు అది ఏ ఉందని నిర్ణయించుకుంటుంది వస్తువు, అది ఒక తప్పుడు గుర్తింపును ఉంది,
మరియు ట్రాక్ పడిపోతుంది.
>> -ది ఇన్కమింగ్ వేగంగా ఎగిరిపోవు అదృశ్యమైన రాడార్ తెర నుంచి.
మరియు సెకన్ల తరువాత, అది శిబిరాలని లోకి స్లామ్డ్.
వేగంగా ఎగిరిపోవు 28 హత్య, మరియు గత ఉంది మొదటి గల్ఫ్ యుద్ధం సందర్భంగా ఒక తొలగించారు.
>> విషాద, నవీకరించబడింది సాఫ్ట్వేర్ దాహ్రాన్ తర్వాత రోజు వచ్చారు.
సాఫ్ట్వేర్ దోషం వచ్చింది ఉన్నాయి స్థిర, ముగింపు
సమస్యాత్మక ఒక అధ్యాయం పాట్రియాట్ క్షిపణి యొక్క చరిత్ర.
>> [వీడియో ప్లేబ్యాక్]
డేవిడ్ J. మలన్: సో ఈ అన్ని ఉంది చెప్పటానికి ఓవర్ఫ్లో ఈ సమస్యలు
మరియు ఖచ్చితంగా చెప్పలేని అన్ని చాలా నిజమైనవి.
కాబట్టి మేము ఎలా ఇక్కడ వచ్చాం?
మేము కేవలం printf గురించి మాట్లాడటం మొదలుపెట్టారు.
మళ్ళీ, ఈ ఫంక్షన్ స్క్రీన్ ఏదో ముద్రిస్తుంది,
మరియు మేము ఆ తరువాత పరిచయం కొన్ని ఇతర విధులు
అని పిలవబడే CS50 యొక్క లైబ్రరీ నుండి.
మరియు మేము కొనసాగిస్తాము కారణంగా సమయంలో వీటిని చూడలేరు.
మరియు మేము, ముఖ్యంగా, స్ట్రింగ్ పొందండి ఉపయోగిస్తారు, మరియు Int పొందుటకు, మరియు ఇప్పుడు కూడా ఫ్లోట్ పొందుటకు,
మరియు ఇంకా ఇతరులు మేము ఎదుర్కునే చాలాకాలంపాటు మమ్మల్ని ఉపయోగించడానికి.
>> కానీ సందర్భంగా కలిగి మేము ఇప్పటికే ఒక అవసరం కనిపించింది
తిరిగి నిల్వ ఏమి ఆ విధులు చేతి?
వారు ఒక స్ట్రింగ్ తిరిగి ఇవ్వు, లేదా ఒక పూర్ణాంకానికి లేదా ఫ్లోట్.
కొన్నిసార్లు మేము ఆ ఉంచాలి స్ట్రింగ్ లేదా Int, లేదా ఫ్లోట్, ఎక్కడో.
>> మరియు ఆ విషయాలు నిల్వ, కేవలం గుర్తుకు స్క్రాచ్ లో వంటి, మేము కలిగి వేరియబుల్స్.
కానీ స్క్రాచ్ లో కాకుండా, సి లో మేము అసలు రకాల కలిగి
వేరియబుల్స్ డేటా రకాల సాధారణంగా
వాటిలో, ఒక స్ట్రింగ్, ఒక Int, ఒక ఫ్లోట్, మరియు ఇప్పటికీ ఈ ఇతరులు.
>> కాబట్టి మేము సి లో వేరియబుల్స్ డిక్లేర్ చేసినప్పుడు, మేము మా డేటా రకాల డిక్లేర్ ఉంటుంది.
ఈ మేము చేస్తాము ఏదో కాదు సెమిస్టర్ లో తరువాత చేయాల్సిందల్లా
వంటి ఇతర భాషలలో బదిలీ.
కానీ ఇప్పుడు కోసం, మేము అవసరం లేదు ముందుగా ఒక ఊహాకల్పిత వరకు,
కంప్యూటర్ రకం వివరించడానికి వేరియబుల్ మేము అది మాకు ఇవ్వాలని.
>> ఇప్పుడు, మరోవైపు, ప్రింట్ డేటా రకాలు రకాల,
మేము ఆశించిన ఏమి printf చెప్పడానికి కలిగి.
మరియు మేము, తీగలు కోసం శాతం లు చూసింది మరియు పూర్ణాంకాల కోసం శాతం నేను,
మరియు కొన్ని ఇతరులు ఇప్పటికే ఒక.
మరియు ఆ కేవలం అవసరాలు దృశ్య ప్రదర్శన కోసం
ఆ సమాచారాన్ని.
>> మరియు ఈ ప్రతి ఒక్కటీ వాస్తవంగా ఉంటుంది పారామితీకరణ లేదా కొన్ని విధంగా tweaked,
మీరు నియంత్రణ కొనసాగింపుకు అనుకుంటే అవుట్పుట్ యొక్క రకం మీరు పొందుటకు.
మరియు, నిజానికి, దాన్ని మాత్రమే మారుతుంది ఒక కొత్త లైన్ కోసం బాక్ స్లాష్ n ఉంది.
వేరే బాక్ స్లాష్ అని ఏదో ఉంది ఒక క్యారేజ్ రిటర్న్, కోసం r ఇది
ఒక పోలిన పాత పాఠశాల టైప్రైటర్,
మరియు కూడా విండోస్ చాలా సంవత్సరాల నుంచి ఉపయోగిస్తున్నారు.
>> టాబ్ల కోసం బాక్ స్లాష్ t ఉంది.
మీరు అనుకుంటే హాజరవుతారు ఒక స్ట్రింగ్ లోపల డబుల్ కోట్,
మేము ఉపయోగించే చేసిన రీకాల్ డబుల్ కోట్ డబుల్
ఎడమ మరియు కుడి కోట్ ఇంతవరకూ మా తీగలను చివరలను.
ఆ విషయాలు తికమక అగుపిస్తుంది.
>> మీరు ఒక డబుల్ కోట్ చాలు అనుకొంటే ఒక స్ట్రింగ్ మరియు, నిజానికి, మధ్యలో
అది చూడటానికి గందరగోళంగా ఉంది.
కాబట్టి మీరు తప్పించుకోవడానికి ఉన్నాయి, కాబట్టి మాట్లాడటం, ఏదో ఒక డబుల్ కోట్
వంటి, వాచ్యంగా, డబుల్ కోట్ బ్యాక్స్లాష్.
మరియు ఇంకా కొన్ని ఇతర వార్తలు.
మరియు మేము ఆ మరింత చూస్తారు దీర్ఘ ముందు వాస్తవ ఉపయోగంలో.
>> కాబట్టి యొక్క ఇప్పుడు నుండి బదిలీ వీలు డేటా, మరియు ప్రాతినిధ్యం,
మరియు గణిత ఆపరేటర్లు, అన్ని వీటిలో కొన్ని భవనం ఇచ్చింది
ఇది బ్లాక్స్ ప్లే.
కానీ ఇప్పుడు యొక్క నిజానికి ఇస్తాను మాకు పదజాలం మిగిలిన
మేము ఇప్పటికే ఉందని స్క్రాచ్ గత వారం
కొన్ని ఇతర వద్ద ఒక పరిశీలించటం ద్వారా సి నిర్మాణాలు వాటిని అన్ని.
కానీ ఆ ఆలోచనలు మేము ఉన్నాము నిజంగా కేవలం చూడటానికి గురించి
నుండి అనువాదం ఒత్తి ఒక భాష, స్క్రాచ్, మరొక, సి
>> మరియు కాలక్రమేణా, మేము పికప్ మా టూల్కిట్ కోసం మరిన్ని ఉపకరణాలు,
పదము, మాట్లాడటానికి.
మరియు, నిజానికి, మీరు ఆలోచనలు చూస్తారు ఇప్పుడు గత వారం నుండి కాకుండా తెలిసిన.
కాబట్టి దీన్ని చూద్దాం.
>> యొక్క ముందుకు వెళ్లి ఒక కార్యక్రమం అప్ రెచ్చిపోయినప్పుడు తెలియజేయండి వాస్తవానికి కొన్ని మాటల్ని ఉపయోగిస్తుంది,
బూలియన్ వ్యక్తీకరణ.
నాకు ఇక్కడ ముందుకు వెళ్ళి తెలపండి ఒక కొత్త ఫైలు సృష్టించవచ్చు.
నేను ఈ condition.c పిలుస్తాను.
>> నాకు ముందుకు వెళ్లి CS50 లైబ్రరీ ఉన్నాయి.
మరియు నాకు ముందుకు వెళ్లి మీకీ మా విధులు కోసం ప్రామాణిక io.h,
మరియు printf, మరియు మరింత వరుసగా.
నాకు నాకు ఆ బాయిలర్ ప్లేట్ ఇవ్వాలని లెట్ దీని వివరణను మేము చేస్తాము Int ప్రధాన గర్జన,
భవిష్యత్తులో తిరిగి రండి.
>> ఇప్పుడు నాకు ముందుకు వెళ్లి ఇక్కడ ఇస్తాను నాకు Int పొందండి ద్వారా ఒక Int.
అప్పుడు నాకు ముందుకు వెళ్లి మనం.
నేను చెప్పాలనుకోవడం నేను less-- చేసుకుందాం ఉంటే , అనుకూల ప్రతికూల ఉన్న తేడాలను
లేదా సున్నా విలువలు.
>> కనుక నేను సున్నా కంటే తక్కువ, నాకు తెలియజేయండి ఈ కార్యక్రమం కేవలం చెప్పటానికి కలిగి,
ప్రతికూల, బాక్ స్లాష్ n, వేరే నేను సున్నా కంటే ఎక్కువ ఉంటే.
ఇప్పుడు నేను, కోర్సు యొక్క, చెప్పాలి printf సానుకూల, బాక్ స్లాష్ n.
ఆపై వేరే నేను ఈ పని చేయడు if--.
>> నేను 0 సమానం నేను అలా.
కానీ నేను వద్ద చేస్తున్నట్లు భావిస్తే ఇప్పటికే కనీసం ఒక తప్పు.
సమాన సైన్ గుర్తుచేసుకున్నారు సమానం కాదు, మనం మానవులు తెలుస్తుంది.
>> కానీ అది కార్య ఆపరేటర్లు.
మరియు మేము, 0 పడుతుంది వద్దు కుడి మరియు ఎడమ i లో అది చాలు.
కాబట్టి ఈ అస్పష్టతను నివారించడానికి, లేదా బహుశా సమానం దుర్వినియోగం సైన్ ఇన్,
మానవులు కొన్ని సంవత్సరాల క్రితం నిర్ణయించుకుంది అనేక ప్రోగ్రామింగ్ భాషల్లో
మీరు సమానత్వం కోసం చెక్ అనుకుంటున్నారా ఉన్నప్పుడు ఎడమ మరియు కుడి మధ్య,
మీరు నిజంగా సమానం సమానం ఉపయోగించవచ్చు.
కాబట్టి మీరు హిట్ సమానం రెండుసార్లు.
మీరు కుడి నుండి కేటాయించవచ్చు ఎడమ, మీరు ఒక ఒకే సమాన సైన్ ఉపయోగించవచ్చు.
కాబట్టి మేము ఈ వేరే చేయగల నేను సమానం ఉంటే సున్నా సమానం.
>> నేను అప్పుడు వెళ్ళి కాలేదు నా గిరజాల జంట కలుపులు తెరిచి,
మరియు సే printf 0, బాక్ స్లాష్ n, పూర్తి.
కానీ ఎలా ఈ గుర్తు రోడ్డు ఫోర్కులు పని చేయవచ్చు.
మరియు, నిజంగా, కేవలం తర్కం గురించి ఆలోచించటం.
నేను ఒక సంఖ్య.
ఇది ప్రత్యేకంగా పూర్ణాంకం.
మరియు అది తక్కువ చేస్తాడు అర్థం 0, లేదా 0, 0 లేదా ఎక్కువ కంటే ఎక్కువ.
కాబట్టి ఈ రకమైన ఉంది ఉద్దేశిత డిఫాల్ట్ కేసు.
>> కాబట్టి మేము, కేవలం ఇష్టం కాలేదు స్క్రాచ్, వేరే ఉంటే అమలుచేయు,
మరియు కేవలం వేరే చెబుతున్నారు.
తార్కికంగా, మీరు ప్రోగ్రామర్ తెలుసు ఉంది మాత్రమే
ఇది ఒక మూడు బకెట్లు దృష్టాంతంలో, మొదటి fall-- చేయవచ్చు
రెండవ, లేదా మూడవ ఈ లేదు కేసు
అదనపు PRECISION జోడించడం ఇబ్బంది మరియు అక్కడ అదనపు తర్కం.
జస్ట్ ముందుకు ఇక్కడ వేరే డిఫాల్ట్ కేసు.
>> ఇప్పుడు, యొక్క ముందుకు వెళ్లి మనం ఈ గండం, తయారు
పరిస్థితులు పరిస్థితుల్లో స్లాష్ డాట్ ఒక గొప్ప యూజర్ ఇంటర్ఫేస్,
నేను ప్రాంప్ట్ లేదు ఎందుకంటే వినియోగదారు, నేను ముందు పేర్కొన్న.
కానీ ఆ మంచిది.
మేము అది సాధారణ ఉంటాం.
యొక్క సంఖ్య 42 ప్రయత్నించండి లెట్.
ఆ సానుకూల ఉంది.
యొక్క సంఖ్య ప్రయత్నించండి లెట్ ప్రతికూల 42, ప్రతికూల.
>> యొక్క విలువ 0 ప్రయత్నించండి లెట్.
మరియు, నిజానికి, ఇది పనిచేస్తుంది.
ఇప్పుడు, మీరు ముందు సమస్యలు తో చూస్తారు పొడవైన, పరీక్ష విషయాలు మూడు సార్లు,
బహుశా సరిపోవు.
మీరు బహుశా కొన్ని పరీక్షించడానికి కావలసిన పెద్ద సంఖ్యలో, కొన్ని చిన్న
సంఖ్యలు, కొన్ని వాయలార్, వంటి మేము వాటిని వివరించడానికి చేస్తాము.
>> ఒక కానీ ఇప్పుడు కోసం, ఈ అందంగా సాధారణ ప్రోగ్రామ్.
నేను తార్కికంగా, అందంగా ఖచ్చితంగా ఉన్నాను, ఇది మూడు కేసులు పడతాడు.
కేవలం మరియు, నిజానికి, మేము అయితే సంభావ్య దుష్ప్రభావాలు పై దృష్టి
ఖచ్చితంగా చెప్పలేని మరియు ఓవర్ఫ్లో యొక్క, లో రియాలిటీ పేరు CS50 యొక్క అనేక సమస్యలకి,
మేము ఆందోళన వెళ్ళడం లేదు గురించి అన్ని సమయం,
ఓవర్ఫ్లో యొక్క ఆ సమస్యలు మరియు ఖచ్చితంగా చెప్పలేని, ఎందుకంటే, నిజానికి, సి,
అది నిజానికి కాదు ఆ విషయాలు నివారించేందుకు సులభం.
మీరు అప్ లెక్కించడానికి కావాలా పెద్ద, పెద్ద, పెద్ద,
ఇది పద్ధతులను ఉన్నాయి హాజరవుతారు తరచుగా అని విషయాలు పాల్గొన్న, ఉపయోగించవచ్చు
గ్రంధాలయాలు, కోడ్ యొక్క సేకరణలు, ఆ మీరు ఉపయోగించే ఇతర వ్యక్తులు రాశాడు,
వంటి మరియు ఇతర భాషలు జావా మరియు ఇతరులు, నిజానికి
ఇది చాలా సులభం కూడా అధిక లెక్కించడానికి.
కనుక ఇది నిజంగా ఈ ప్రమాదాలను కొన్ని ఉంది మీరు ఉపయోగించడానికి భాష యొక్క ఒక ఫంక్షన్.
మరియు రాబోయే వారాలలో, మేము చేస్తాము నిజంగా ఎంత హానికరమో సి చూడండి
మీరు దీనిని ఉపయోగించడానికి లేదు ఉంటే.
కానీ అక్కడ నుండి, మరియు పైథాన్, జావాస్క్రిప్ట్, ఉంటుంది
మేము కొన్ని అదనపు రక్షణలు లో పొర, మరియు ఆ నష్టాలను తక్కువ అమలు.
>> కాబట్టి యొక్క తయారు చేద్దాము కొంచెం మా కార్యక్రమంలో ఆసక్తికరమైన తర్కం.
నాలో ముందుకు వెళ్లి సృష్టించడానికి వీలు లాజికల్ అనే ప్రోగ్రామ్
కేవలం నేను కొంత ప్లే చేయవచ్చు అసలు తర్కం, logical.c.
నేను కాపీ మరియు కొన్ని పేస్ట్ చేస్తాము అంతకుముందు నుండి కోడ్ నేను తిరిగి
ఈ nice ప్రారంభ స్థానం.
>> నేను చార్ సి నాకు ఈ సమయంలో లెట్ అది సి ఒక పేరు ఇవ్వడం
ఇది సంప్రదాయ కనుక, వినియోగదారు నుండి ఒక పాత్ర పొందడానికి.
మరియు యొక్క నటిస్తారు తెలియజేయండి నేను భాగంగా అమలు చేస్తున్నాను
ఆ RM కార్యక్రమం, తొలగిస్తాయి ఆ ముందు కార్యక్రమం వినియోగదారు ప్రాంప్ట్
ఒక ఫైల్ తొలగించడానికి.
మేము ఎలా ఏమి కాలేదు?
>> సి సమానం నేను అంతరంలో సమానం కోట్ unquote,
వై, అప్పుడు నేను అనుకునేది వెళుతున్న యూజర్ అవును ఎంచుకుంది.
నేను అవును ప్రింట్ వెళుతున్న.
నిజానికి రాసే తొలగింపు కార్యక్రమం,
మేము ఫైల్ తొలగించి వేస్తుంది కోడ్ యొక్క పంక్తులను.
కానీ మేము అది సాధారణ ఉంటాం.
>> ఎల్స్ సి సమానం n-- సమానం మరియు ఇప్పుడు ఇక్కడ, నేను చెప్పడానికి వెళుతున్నాను
వినియోగదారుకు అర్థం ఉండాలి.
ఆపై వేరే, మీరు ఏమి?
నేను ఏమి తెలియదు యూజర్ టైపు అన్నారు.
సో నేను చెప్పడానికి వెళుతున్నాను ఒక దోషం, సంసార
అతను లేదా ఆమె నిజానికి టైప్.
>> సో వాట్ ఇక్కడ జరగబోతోంది?
ఒక ప్రాథమిక వ్యత్యాసం ఉంది నేను గతంలో చేసిన ఏ వర్సెస్.
డబుల్ కోట్స్, డబుల్ కోట్స్, డబుల్ కోట్స్, మరియు ఇంకా, సింగిల్ కోట్స్,
సింగిల్ కోట్స్.
ఇది ఉన్నప్పుడు, సి హాజరవుతారు మీరు ఒక స్ట్రింగ్ రాయాలనుకుంటున్నాను,
మీరు డబుల్ కోట్స్ ఉపయోగించడానికి ఏమి మేము చేసిన కేవలం వంటి printf తో అన్ని ఈ సమయంలో ఉపయోగించి చేయబడ్డాయి.
>> కానీ మీరు కేవలం ఒక పరిష్కరించేందుకు అనుకుంటే ఒకే పాత్ర, ఒక అని పిలవబడే చార్,
అప్పుడు మీరు నిజంగా సింగిల్ కోట్స్ ఉపయోగించడానికి.
ప్రోగ్రామ్ చేసిన ఎవరు మీరు యొక్క ఆ ముందు, మీరు లేకపోవచ్చు
ఈ గురించి ఆందోళన కలిగి కొన్ని భాషలలో వ్యత్యాసం.
సి, అది అవసరం.
కాబట్టి నేను ఒక చార్ పొందుటకు మరియు నేను కావలసిన సమానం ఉపయోగించి ఆ చార్ పోల్చడానికి
Y లేదా n వంటి కొన్ని లేఖ సమానం, నేను, నిజానికి, సింగిల్ కోట్స్ కలిగి ఉండాలి.
>> ఇప్పుడు, యొక్క ముందుకు వెళ్లి మనం.
యొక్క ముందుకు వెళ్లి తయారు మనం తార్కిక డాట్ తార్కిక స్లాష్.
ఇప్పుడు నేను ప్రాంప్ట్ అయామ్.
చాలావరకు మెరుగైన యూజర్ అనుభవాన్ని ఇక్కడ ఏమి నిజానికి నాకు తెలియచేయును.
కానీ నేను గుడ్డిగా వెళుతున్న అవును, సరే, బాగుంది వై చెప్పటానికి.
>> ఏ, nice యొక్క మళ్లీ అమలు లెట్, ఎన్.
నాకు తెలుసు కొన్ని ప్రజలు వంటి ఊహించు, నా పరిమితులను కీ చాలా తరచుగా అన్ని ఉంది లాక్.
నేను, రాజధాని Y, ఎంటర్ చేయండి లోపం.
సరే, అది నేను ఆశించే వెబ్ ఏమి ఖచ్చితంగా కాదు.
నిజానికి, కంప్యూటర్ అక్షరాలా ఏమి ఉంది
నేను తనిఖీ చేయాలని చెప్పారు చిన్నబడి y మరియు చిన్నబడి n.
ఈ మంచి భావిస్తాను లేదు యూజర్ అనుభవం, అయితే.
నాకు అడగండి లెట్ మరియు అంగీకరించాలి దిగువ బడిలో లేదా అప్పర్ కేస్ గాని.
దాన్ని మారుతుంది కాబట్టి, మీరు అనుకోవచ్చు స్క్రాచ్ వంటి ఏదో చెప్పడానికి,
వంటి వాచ్యంగా లేదా C సమానం రాజధాని ఒకే కోట్ y సమానం.
హాజరవుతారు, సి కలిగి లేదు ఈ సాహిత్య కీవర్డ్ లేదా.
>> కానీ అది రెండు నిలువు బార్లు లేవు.
మీరు సాధారణంగా షిఫ్ట్ ఉంచి ఉంటుంది, మీరు ఒక యుఎస్ కీబోర్డ్ ఉపయోగిస్తున్నట్లయితే,
మరియు నిలువు బార్ నొక్కండి మీ తిరిగి కీ పైన కీ.
కానీ ఈ నిలువు బార్ నిలువు బార్ అంటే లేదా.
>> అయితే, దీనికి భిన్నంగా, మనం కోరుకున్న స్క్రాచ్ లాగే చెప్పాలో మరియు,
మేము ఆంపర్సండ్ చిహ్నం చేయడు.
ఇక్కడ ఏ లాజికల్ అర్ధమే, ఎందుకంటే ఒక మానవ బహుశా చేయలేని
టైప్ చేసిన y మరియు చిన్నబడి వై రెండు మరియు అదే పాత్ర వంటి మూలధన వై.
సో లేదా మనం ఇక్కడ ఉద్దేశం.
>> నేను రెండు ప్రదేశాల్లో దీన్ని అయితే, లేదా సి సమానం రాజధాని N, ఇప్పుడు తిరిగి సమానం,
తార్కిక తయారు, తార్కిక తిరిగి.
ఇప్పుడు, నేను y టైప్ చేయవచ్చు.
నేను మళ్ళీ దీన్ని చెయ్యవచ్చు రాజధాని Y, లేదా పెట్టుబడి ఎన్
మరియు నేను అదనపు చేర్చండి కాలేదు ఇప్పటికీ కలయికలు.
>> కాబట్టి ఈ ఒక తార్కిక ఉంది ఇప్పుడు అజమాయిషీ కార్యక్రమం
నేను తార్కికంగా తనిఖీ చేస్తున్నాను ఈ విలువ లేదా ఈ విలువ.
నేను, లేదు తప్పనిసరిగా మరో రెండు పలికి లేదంటే పలికి ఆలోచన.
నేను నిజానికి కొన్ని మిళితం చేయవచ్చు ఈ విధంగా కలిసి సంబంధిత తర్కం.
కాబట్టి ఈ మంచిదని కేవలం కన్నా రూపకల్పన
సి కేసు వై తక్కువ సమానం సెలవిచ్చెను సి రాజధాని Y సమానం అవును ప్రింట్ వేరే,
సి సమానం అవును ప్రింట్ వేరే ఇతర మాటలలో lower--,
మీరు ఉండాలి లేదు మరింత శాఖలు.
మీరు సమానమైన కొన్ని మిళితం చేయవచ్చు తార్కికంగా శాఖలు, ఈ విధంగా.
>> కాబట్టి యొక్క కేవలం ఒక పరిశీలించి వీలు చివరి అంశంగా జరిగిన ఫైనల్ నిర్మాణమని
సి అనుమతిస్తుంది.
మరియు మేము తిరిగి వచ్చి చేస్తాము ఇప్పటికీ ఇతరులకు భవిష్యత్తు.
మరియు తర్వాత మేము చూడటం ద్వారా ముగుస్తుంది చేస్తాము కాదు ఉంటుంది కోడ్ యొక్క సరి వద్ద
work-- అయితే రూపకల్పన కోడ్ పొందడానికి కోడ్, మరియు ప్రారంభ ఆ విత్తనాలను నాటడం.
>> నాలో ముందుకు వెళ్లి ఇక్కడ ఒక కొత్త ఫైల్ తెరుచుకుంటుంది.
నీకు తెలుసా?
నేను తిరిగి ప్రవేశపెట్టాలని వెళుతున్న అదే కార్యక్రమంలో,
కానీ వేరే నిర్మాణం ఉపయోగించి.
>> సో నాకు ఇవ్వాలని త్వరగా నాకు తెలియజేయండి ప్రాప్తి CS50.h చేర్చడానికి
CS50 లైబ్రరీ కోసం, printf కోసం ప్రామాణిక io.h.
నా Int ప్రధాన గర్జన ఇవ్వండి.
మరియు ఇక్కడ పైగా, వీలు నాకు ముందుకు వెళ్లి ఇలా.
>> చార్ సి కేవలం ముందు వంటి చార్ ను గెట్స్.
నేను ఒక కొత్త నిర్మాణం ఉపయోగించడానికి వెళుతున్న ఏమి పాత్ర, స్విచ్ ఇప్పుడు?
కాబట్టి స్విచ్ వంటి రకమైన ఉంది ఒక రైలు ట్రాక్లను మార్పిడి.
లేదా, నిజంగా, అది రకమైన ఉంది ఒక else ఉంటే, వేరే ఉంటే,
కానీ కొంతవరకు భిన్నంగా రాసిన.
>> ఒక స్విచ్ ఈ కనిపిస్తోంది.
మీరు స్విచ్ కలిగి, మరియు అప్పుడు ఏమి పాత్ర లేదా మీరు చూడండి మీరు సంఖ్య,
అప్పుడు కొన్ని వంకర జంట కలుపులు ఇష్టం స్క్రాచ్, ఈ విషయాన్ని చెప్పే.
ఆపై మీరు వివిధ సందర్భాలలో ఉన్నాయి.
>> మీరు ఉంటే మిగిలిన ఉపయోగించడానికి లేదు.
మీరు వాచ్యంగా పదం సందర్భంలో.
మరియు మీరు ఈ వంటి ఏదో చెబుతా.
>> కాబట్టి ఒక చిన్న y యొక్క సందర్భంలో, లేదా ఒక రాజధాని Y విషయంలో,
ముందుకు వెళ్ళి మరియు అవును ప్రింట్.
ఆపై స్విచ్ యొక్క బయటకు.
అంతే.
చేసారు, చెయ్యబడినది.
>> మాట్లాడటానికి, ఎల్స్, తక్కువ కేసు n, లేదా రాజధాని N,
ముద్రణ ముందుకు వెళ్ళి బయటకు సంఖ్య, మరియు తరువాత విడిపోయారు.
Else-- మరియు ఈ రకమైన ఉంది డిఫాల్ట్ సందర్భంలో indeed-- printf తప్పు,
మరియు కేవలం మంచి కొలత కోసం అయితే, తార్కికంగా ఈ విరామం అవసరం లేదు
మేము చివరిలో ఉన్నారు ఎందుకంటే ఏమైనప్పటికీ స్విచ్ యొక్క,
నేను ఇప్పుడు స్విచ్ యొక్క బద్దలు చేస్తున్నాను.
కాబట్టి ఈ చిన్న భిన్నంగా కనిపిస్తోంది.
>> కానీ, తార్కికంగా, అంతే నిజానికి సమానమైన.
ఎందుకు మీరు ఉపయోగించే ఇతర మీద ఒక?
కొన్నిసార్లు, కేవలం వ్యక్తిగత ప్రాధాన్యత, కొన్నిసార్లు అలంకారం
నేను ఈ వద్ద మెరుపు ఉంటే ఇప్పుడు విషయం ఏదైనా
చెప్పబడుతోంది ఈ కోడ్ యొక్క చదవడానికి.
నా ఉద్దేశ్యం, ఈ వాస్తవం పర్వాలేదు కోడ్ గదిలో మనలో చాలా మంది కొత్త ఉంది.
>> కానీ అది కేవలం రకమైన అందంగా ఉంది.
మీరు చిన్నబడి Y, రాజధాని Y చూడండి, తక్కువ కేసు n, రాజధాని N డిఫాల్ట్,
అది కేవలం రకమైన హెచ్చుతగ్గుల ఒక విధంగా మీకు
నిస్సందేహంగా, బహుశా, ఆ మునుపటి ఉదాహరణ
పలికి, మరియు నిలువు బార్లు తో, మరియు మిగతా పలికి, లేకపోవచ్చు.
కాబట్టి ఇది వ్యక్తిగత నిజంగా ఒక విషయం ఎంపిక, నిజంగా, లేదా చదవడానికి,
కోడ్ యొక్క.
>> కానీ ఫంక్షనాలిటీ పరంగా, నాకు తెలియజేయండి ముందుకు వెళ్లి ఒక స్విచ్, డాట్ స్లాష్ చేయడానికి
స్విచ్, మరియు ఇప్పుడు, చిన్న y లో టైప్ రాజధాని Y, చిన్న n, రాజధాని N,
డేవిడ్, ఆ ఎందుకంటే చేయడాన్ని మళ్లీ ఒక ఏకాక్షరం.
అనుకున్న, x, లోపం తెలియజేసేలా.
మరియు, logically-- మరియు ఈ విషయం నేను general-- కూడా ప్రోత్సహిస్తుంది
మనం మాత్రమే గోకడం చేస్తున్నారు అయితే ఈ లక్షణాలు కొన్ని ఉపరితల.
>> మరియు అది స్పష్టంగా ఉండకపోవచ్చని నువ్వు ఎప్పుడు మీరే కీబోర్డ్ వద్ద డౌన్ కూర్చుని,
ఎలా పని చేస్తుంది?
ఈ ఏమి చేస్తుంది?
గురించి అందమైన విషయం ఒక ల్యాప్టాప్, లేదా డెస్క్టాప్, లేదా యాక్సెస్
ఒక కంపైలర్ ఒక కంప్యూటర్కు, మరియు ఈ వంటి ఒక కోడ్ ఎడిటర్ తో,
మీరు దాదాపు ఎల్లప్పుడూ ఈ జవాబివ్వడానికి ఉంది కేవలం ప్రయత్నిస్తూ ద్వారా మీ కోసం ప్రశ్నలు.
>> ఉదాహరణకు, అలంకారిక ఉంటే చేతి ప్రశ్నార్థకంగా ఉన్నాయి,
మీరు మర్చిపోతే ఏమవుతుంది మీ విరామం ప్రకటనలు?
ఏ ఉంది, నిజానికి ఒక చాలా సాధారణ పనిని చేయడానికి,
అనిపించడం లేదు ఎందుకంటే వంటి మీరు నిజంగా వాటిని అవసరం.
వారు నిజంగా పూర్తి లేదు మీ ఒక కుండలీకరణములలో లేదా ఒక వంకర వంటి భావించారు
కలుపు చేస్తుంది.
యొక్క ముందుకు వెళ్లి మళ్ళీ కంపైల్ చెయ్యండి కోడ్ మరియు చూడండి.
కాబట్టి స్విచ్, డాట్ స్లాష్ మార్చాలా.
దిగువ కేసు టైప్ లెట్ Y, టాప్ కేసు నమోదు చేయండి.
కాబట్టి నేను y టైప్.
>> కార్యక్రమం ఏ, అవును చెప్పారు, లోపం, అయితే దానిని దాని మనస్సును మార్చటం జరిగింది.
ఏమి జరుగుతుంది ఎందుకంటే కానీ రకమైన ఉంది ఒక స్విచ్ తో మొదటి సందర్భంలో అని
మ్యాచ్ తప్పనిసరిగా అర్థం, హే కంప్యూటర్, దాని కింద కోడ్ అన్ని అమలు.
మరియు మీరు చెప్పే లేకపోతే బ్రేక్, లేదా బ్రేక్ చెప్పడానికి లేదు, లేదా బ్రేక్ చెప్పడానికి లేదు,
కంప్యూటర్ వీచడం అన్నారు ఆ రేఖల అన్ని ద్వారా
వరకు వాటిలో అన్ని అమలు ఆ వంకర కలుపు పొందుతాడు.
కాబట్టి బ్రేక్లు అవసరం, నిజానికి, ఉన్నాయి.
కానీ ఇక్కడ ఒక తాత్కాలిక పెట్టదు సందేహం, ఏదో ప్రయత్నించండి.
బహుశా మొదటి మీ కోడ్ సేవ్, లేదా ఒక అదనపు ఫైల్ లో సేవ్
మీరు నిజంగా గురించి భయపడి మీరు అప్ సమస్యను మరియు తిరిగి కలిగి
మీకు తెలిసిన ఆ పని పనిచేస్తోంది.
>> కానీ విషయాలు ప్రయత్నించండి.
మరియు బహుశా, వంటి బయపడకండి, కంప్యూటర్ ఏమి చేస్తారో,
లేదా మీరు ఏదో బ్రేక్ చేసే.
మీరు ఎల్లప్పుడూ తిరిగి మారవచ్చు కొన్ని మునుపటి సంస్కరణకు.
>> కాబట్టి యొక్క చూడటం ద్వారా అంతం తెలియజేయండి కోడ్ నమూనాను.
మేము రాయడం ఇప్పుడు ఈ సామర్ధ్యాన్ని కలిగి ఉంటాయి పరిస్థితులు, మరియు వ్రాయడం ఉచ్చులు,
మరియు వేరియబుల్స్ మరియు కాల్ విధులు.
కాబట్టి, స్పష్టముగా, మేము రకమైన వెనుక ఉన్నాము ఇక్కడ మేము స్క్రాచ్ తో ఒక వారం క్రితం,
తక్కువ బలవంతపు పాఠ్య ఉన్నప్పటికీ స్క్రాచ్ కంటే పర్యావరణ అనుమతిస్తుంది.
>> కానీ మేము కొనుగోలు చేసిన ఎంత త్వరగా గమనించవచ్చు ఆ పదజాలం, అయినా
మునిగిపోతుంది కొద్దిసేపట్లో తీసుకుంటున్నానని, మేము ఇప్పుడు ఈ పదజాలం ఉపయోగించే కాబట్టి
మరింత ఆసక్తికరమైన కార్యక్రమాలు రాయడానికి.
మరియు యొక్క ఒక పిల్ల దశ తీసుకుందాం ఆ వైపు, వంటి అనుసరిస్తుంది.
నాకు ముందుకు వెళ్లి ఇక్కడ ఒక కొత్త ఫైల్ సృష్టించడానికి.
>> నేను ఈ కాల్ వెళుతున్న prototype.c, మరియు పరిచయం
మొదటిసారి, సామర్థ్యం మీ సొంత విధులు తయారు.
మీలో కొంతమంది ఉండవచ్చు స్క్రాచ్ తో ఈ చేసిన,
అనగా మీరు సృష్టించవచ్చు మీ స్క్రాచ్ లో స్వంత కస్టమ్ బ్లాక్స్,
ఆపై స్థానంలో వాటిని డ్రాగ్ ఎక్కడ మీరు C. లో చేర్చదలచిన
మరియు అనేక ప్రోగ్రామింగ్ లో భాషలు, మీరు ఖచ్చితంగా దీన్ని చెయ్యవచ్చు
ఆ మీ సొంత విధులు తయారు, వారు ఇప్పటికే ఉనికిలో లేకపోతే.
>> కావున, ఉదాహరణకు, నాకు ముందుకు తెలియజేయండి మరియు cs50.h ఉన్నాయి, మరియు చేర్చబడెను
ప్రామాణిక io.h, Int ప్రధాన శూన్యమైన.
మరియు ఇప్పుడు మేము ఒక కలిగి సిద్ధంగా హోల్డర్.
నేను ప్రింటింగ్ విషయాలను నేటి ప్రజల పేర్లు వంటి.
మరియు ఆ వంటి ఫంక్షన్ అనిపిస్తుంది nice కాదు ఉంటే అక్కడ
ముద్రణ పేరు అని ఒక ఫంక్షన్ ఉన్నాయి?
నేను printf ఉపయోగించడానికి లేదు.
నాకు గుర్తు లేదు అన్ని ఫార్మాట్ సంకేతాలు.
ఎందుకు చేయరు నేను, లేదా ఎందుకు నాకు ముందు ఎవరైనా జరగలేదు
అని ఒక ఫంక్షన్ ముద్రణ సృష్టించడానికి పేరు, కొన్ని పేరు ఇచ్చిన,
కేవలం దాన్ని ముద్రిస్తుంది?
>> ఇతర మాటలలో, నేను, హే చెప్పుకోవాలంటే, కంప్యూటర్, నాకు స్ట్రింగ్ ఇవ్వాలని
ఇటువంటి యూజర్ అడగడం ద్వారా CS50 యొక్క స్ట్రింగ్ ఫంక్షన్ ద్వారా.
హే, కంప్యూటర్, ఆ తీగ చాలు ఎడమ చేతి వైపు వేరియబుల్,
మరియు s కాల్.
ఆపై, హే కంప్యూటర్, ముందుకు వెళ్ళి మరియు వ్యక్తి యొక్క పేరు, పూర్తి ప్రింట్.
>> ఇప్పుడు, ఎందుకంటే బాగుండేది ఈ కార్యక్రమం, సముచితంగా అనే పేరు
అది ఏమి చేయాలో ఏమి నాకు చెబుతుంది ఆ ఫంక్షన్ యొక్క పేర్లు జరుగుతుంది.
నాకు వెళ్ళి నమూనా తయారు, ఎంటర్ లెట్.
మరియు, దురదృష్టవశాత్తు, ఈ ఫ్లై వెళ్ళడం లేదు.
>> Prototype.c, లైన్ 7, పాత్ర 5, లోపం, అవ్యక్త ప్రకటన
ఫంక్షన్ ముద్రణ పేరు C99 లో, C99 చెల్లదు
సి యొక్క ఒక వెర్షన్ అర్ధం 1999 లో వచ్చింది.
అంతే.
>> నేను తెలియదు ఏమి ఈ అన్ని ఇంకా అర్థం.
కానీ నేను ఎరుపు లో లోపం గుర్తిస్తాయి.
ఆ అందంగా స్పష్టమైన ఉంది.
>> మరియు అది తెలుస్తుంది ఇక్కడ ఆకుపచ్చ పాత్ర
సమస్య ముద్రణ పేరుతో ఓపెన్ బ్రాకెట్ లు, దగ్గరగా బ్రాకెట్, సెమీ కోలన్.
కానీ పరిపూర్ణ ప్రకటన ఫంక్షన్ మేము కొంతకాలం ముందు చూడండి చేసింది.
ఈ కేవలం అర్థం, గణగణమని ద్వని చేయు వాట్ ఐ మీన్ తెలీదు.
>> అంతే నేను పదజాలం పదం ఉపయోగించారు చేసిన చూడని లేదా ముందు బోధించాడు.
కాబట్టి నేను బోధించే అవసరం ఈ ఫంక్షన్ అర్థం.
నేను ముందుకు వెళ్లి అలా వెళుతున్న.
>> నేను ముందుకు వెళ్లి అమలు వెళుతున్న ముద్రణ పేరు అని నా సొంత ఫంక్షన్.
నేను చెప్పటానికి, క్రింది విధంగా, ఆ వెళుతున్న ఈ printf, హలో, శాతం చేస్తుంది
లు, బాక్ స్లాష్ n, పేరు, సెమీ కోలన్.
సో నేను ఏం చేసావ్?
>> కాబట్టి దానికి హాజరవుతారు, మీ స్వంత ఫంక్షన్ అమలు,
మేము రకమైన కొన్ని రుణాలు ప్రధాన అదే నిర్మాణం
మేము కేవలం చేసిన మంజూరు కోసం తీసుకున్న, మరియు నేను
తెలిసిన కేవలం కాపీ మరియు చాలా చక్కని ఏ అతికించడానికి
నేను గతంలో రాయడం చేసిన.
కానీ ఇక్కడ నమూనా గమనించవచ్చు.
ఇంట్, మెయిన్ శూన్యం, మేము దూరంగా బాధించటం చేస్తాము ముందు కాలం వాస్తవానికి అర్థం.
>> అయితే ఈ రోజు కోసం, కేవలం సమాంతరత గమనించవచ్చు.
శూన్యం, ముద్రణ పేరు, స్ట్రింగ్ పేరు, కాబట్టి ఉంది
ఒక ఊదా కీవర్డ్, ఇది మేము ఆరంభమవుతుంది చేస్తున్నారు
తిరిగి టైప్ పిలుపు పేరు ఫంక్షన్, ఆపై ఇన్పుట్.
కాబట్టి, నిజానికి, మేము పరిశుద్ధం చేయవచ్చు గత వారం వంటి ఈ రకమైన
వంటి, ఈ పేరు లేదా కోడ్ మేము ఉన్నాము అల్గోరిథం
వ్రాయండి అన్నారు అల్గోరిథం అంతర్లీన
కోడ్ మేము రాయాలో.
>> ఈ దాని ఇన్పుట్ ఉంది.
ఈ దాని అవుట్పుట్ ఉంది.
ఈ ఫంక్షన్, ముద్రణ పేరు, పేరు అనే స్ట్రింగ్ పొందడానికి ఆకృతి,
లేదా సంసార, ఇన్పుట్, ఆపై శూన్యమైన.
ఇది ఏదైనా తిరిగి లేదు వంటి స్ట్రింగ్ పొందండి లేదా Int చేస్తుంది పొందండి.
కాబట్టి మళ్ళీ నాకు ఏదో హ్యాండ్ జరగబోతోంది.
ఇది కేవలం ఒక కలిగి జరగబోతోంది దుష్ప్రభావానికి మాట్లాడటానికి,
ఒక వ్యక్తి యొక్క పేరు ప్రింటింగ్.
ప్రకటన కాబట్టి, లైన్ 7, నేను ముద్రణ పేరు కాల్ చేయవచ్చు.
లైన్ 10, నేను నిర్వచించలేదు లేదా ముద్రణ పేరు అమలు.
కానీ, దురదృష్టవశాత్తు, ఆ తగినంత.
>> నాకు ముందుకు వెళ్లి గండం ఈ మళ్ళీ కంపైల్ చెయ్యండి.
అయ్యో, ఇప్పుడు, నేను చేసిన పైపెచ్చు అది కనిపిస్తుంది.
సో అవ్యక్త ప్రకటన ఫంక్షన్ ముద్రణ పేరు చెల్లనిది.
మరియు, మళ్ళీ, లోపాలను వార్తలు.
కానీ నేను కూడా ముందు హెచ్చరించారు గా మీరు తో నిమగ్నం ఉంటే,
లేదా చాలా చూడటానికి ఒక చిన్న విచారంగా లోపాలు, మొదటి మీద మాత్రమే దృష్టి పెట్టాలి
కేవలం ప్రారంభంలో, ఎందుకంటే అది బలం కాస్కేడింగ్ ప్రభావం చూపాయి.
కాబట్టి, మరింత ప్రత్యేకంగా సి, లేదా గణగణమని ద్వని చేయు అచ్చువేసే పేరు గుర్తించాలని లేదు.
>> మరియు గణగణమని ద్వని చేయు యొక్క, డిజైన్ ద్వారా, రకమైన మూగ ఉంది.
ఇది మాత్రమే మీరు దాని గురించి చెప్పడం దేనిని.
మరియు అది మాత్రమే క్రమంలో కాబట్టే మీరు దాని గురించి చెప్పడం.
>> నేను లైన్ నాలుగు ప్రధాన నిర్వచించారు, వంటి మేము చాలా తరచుగా చేయడం పరిష్కరించగలుగుతున్నాము.
నేను లైన్ 10 ముద్రణ పేరు నిర్వచించిన చేసిన.
కానీ నేను ఉపయోగించడానికి దీనికై లైన్ ఏడు ముద్రణ పేరు.
>> ఇది చాలా త్వరగా, ఇంకా ఉనికిలో లేని ఉంది.
కాబట్టి నేను తెలివైన, మరియు వంటి కావచ్చు, OK, కాబట్టి యొక్క కేవలం పాటు ప్లే వీలు,
మరియు ముద్రణ పేరు పైకి తరలించు ఇక్కడ, మరియు తిరిగి కంపైల్.
ఓరి దేవుడా.
అది పనిచేసింది.
ఇది అంత సులభమైనది ఉంది.
>> కానీ తర్కం ఖచ్చితంగా ఉంది.
మీరు గణగణమని ద్వని చేయు బోధించడానికి కలిగి ఏమి అది మొదటి ఫంక్షన్ నిర్వచించడం ద్వారా ఉంది.
అప్పుడు మీరు దీన్ని ఉపయోగించవచ్చు.
కానీ, స్పష్టముగా, ఈ భావం జారిపోవడానికి వంటి.
>> కాబట్టి ప్రతి సమయం నేను అమలు ఒక సమస్య, నేను రెడీ
హైలైట్ మరియు కోడ్ కాపీ వెళుతున్న నేను అది కట్ మరియు ఇక్కడ దానిని పేస్ట్, రాశాడు.
మరియు, ఖచ్చితంగా, మేము అని కొన్ని విషయాలు నైపుణ్యం
ఇక్కడ ఒక ఫంక్షన్ ఉండవచ్చు మరో కాల్ చేయాలి.
మరియు మీరు కేవలం ప్రతి చాలు కాదు ప్రతి ఇతర పైన ఫంక్షన్.
>> కనుక ఇది ఉంది అది మారుతుంది ఒక మంచి పరిష్కారం.
మేము ఈ ఉంటుంది వదిలివేయండి.
మరియు, స్పష్టముగా, అది సాధారణంగా మంచిది, మరియు అనుకూలమైన, మరియు మంచి డిజైన్
, మొదటి ప్రధాన ఉంచాలి ఎందుకంటే, మళ్లీ, కేవలం ఆకుపచ్చ జెండా క్లిక్ చేసినప్పుడు వంటి ప్రధాన,
ఆ ఫంక్షన్ అని అప్రమేయంగా అమలు అవుతుంది.
కాబట్టి మీరు అలాగే ఉంచారు ఉండవచ్చు ఫైలు ఎగువన
కాబట్టి మీరు లేదా ఏదైనా ఉన్నప్పుడు ఇతర మానవ ఫైలు చూసి
మీరు జరగబోతోంది ఏమి కేవలం ప్రధాన మొదటి చదవడం ద్వారా.
దాన్ని మారుతుంది కాబట్టి, మేము గణగణమని ద్వని చేయు తెలియజేయవచ్చు ముందుగా, హే, గణగణమని ద్వని లైన్ నాలుగు న,
నేను అమలు వాగ్దానం అని ఒక ఫంక్షన్ ప్రింట్
ఒక అని స్ట్రింగ్ పేరు వచ్చింది అని పేరు ఇన్పుట్ మరియు తిరిగి ఏమీ, శూన్యమైన వంటి.
నేను చుట్టూ పొందుతారు తరువాత అది అమలు.
>> ఇక్కడ ప్రధాన వస్తుంది.
ప్రధాన ఇప్పుడు లైన్లో 9 ఉపయోగించవచ్చు ముద్రణ పేరు గణగణమని ద్వని చేయు
చివరికి, ఆ విశ్వాసం, ఇది నిర్వచనం ఎదుర్కునే
ముద్రణ పేరు అమలు.
కాబట్టి నా ఫైలు సేవ్ తర్వాత, వీలు నాకు ముందుకు వెళ్లి నమూనా తయారు,
ఈ సమయంలో బాగుంది.
డాట్ స్లాష్ నమూనా, నాకు తెలియజేయండి ముందుకు వెళ్లి ఒక పేరును టైప్.
డేవిడ్, డేవిడ్ హలో, Zamila, హలో Zamila మరియు, నిజానికి, ఇప్పుడు అది పనిచేస్తుంది.
>> కాబట్టి ఇక్కడ పదార్ధం మేము చేసిన ఉంది కస్టమ్ వంటి, ఒక అనుకూల ఫంక్షన్ చేసిన
స్క్రాచ్ బ్లాక్ మేము అది కాల్ చేస్తున్నారు.
కానీ స్క్రాచ్ కాకుండా ఇందులో మీరు కేవలం దానిని సృష్టించి ఉపయోగించడం ప్రారంభించడానికి,
ఇప్పుడు మేము ఒక ఉండాలి చిన్న, మరింత పాండిత్య ప్రకర్ష
మరియు వాస్తవానికి గణగణమని ద్వని చేయు శిక్షణ ఉపయోగించడానికి, లేదా అది ఆశించడం.
ఇప్పుడు, ఎందుకు ఈ సమయం జనాంతికంగా, వంటి మేము సహా విశ్వాసం గుడ్డిగా జరిగింది
Cs50.h, మరియు ప్రామాణిక io.h సహా €
>> బాగా, అది అవుతుంది, కొన్ని ఇతర విషయాలతోపాటు,
అన్ని ఆ డాట్ h వార్తలు జరిగే ఫైళ్లు, ఫైళ్లను.
వారు మాట్లాడటానికి, శీర్షిక ఫైళ్లు చేస్తున్నారు.
వారు ఇప్పటికీ C. రాసిన చేస్తున్నారు కానీ వారు ఫైల్ యొక్క వేరొక రకం ఉన్నాము.
>> ఇప్పుడు కోసం, మీరు చాలా చక్కని ఊహించుకుని Cs50.h యొక్క లోపల అని అన్ని ఆ
ఈ వంటి కొన్ని హాస్యోక్తులు కాదు ముద్రణ పేరు అభ్యర్థిస్తున్న ఫంక్షన్ల కోసం,
కానీ స్ట్రింగ్ పొందండి పొందండి ఫ్లోట్, మరియు కొన్ని ఇతరులు.
మరియు ఇలాంటి నమూనాలను ఉన్నాయి, ఒక లీనియర్స్, ప్రామాణిక io.h లోపలి
దీనిలో ఇప్పుడు printf, కోసం నా సొంత ముద్రణ పేరు ఫంక్షన్.
కాబట్టి ఇతర మాటలలో, ఈ మొత్తం సమయంలో మేము చేసిన గుడ్డిగా కాపీ మరియు పేస్ట్ జరిగింది
ఈ ఉన్నాయి ఆ, ఏం జరగబోతోంది?
ఆ ఆధారాలు కేవలం ఒకరకమైన ఏమి విధులకు వంటి గణగణమని ద్వని చేయు కు
ఉంటాయి, నిజానికి, కేవలం అమలు, మరెక్కడా వివిధ ఫైళ్లు
మరెక్కడా వ్యవస్థపై.
>> కనుక మనం ప్రింట్ పేరు అమలు చేసిన.
ఇది ఈ దుష్ఫలితం ఉంటాయా స్క్రీన్ ప్రింటింగ్ ఏదో.
కానీ అది నిజంగానే నాకు ఏదో తిరిగి అప్పగించండి.
ఎలా మేము గురించి ఎలా గో ఒక కార్యక్రమాన్ని అమలు చేసే
నాకు ఏదో తిరిగి అప్పగించండి లేదు?
>> సరే, ఈ ప్రయత్నించండి తెలియజేయండి.
నాకు ముందుకు వెళ్లి అమలు లెట్ అనే ఫైల్ return.c
కాబట్టి మేము ఏదో ప్రదర్శిస్తుంది వంటి స్ట్రింగ్ పొందండి లేదా Int పొందండి,
నిజానికి తిరిగి ఉంది వినియోగదారు తిరిగి ఏదో.
యొక్క ముందుకు వెళ్లి Int ప్రధాన గర్జన నిర్వచించే తెలియజేయండి.
>> మరియు, మళ్ళీ, భవిష్యత్తులో, మేము చేస్తాము ఆ Int మరియు శూన్యమైన వాటిని వివరించడానికి
వాస్తవానికి చేయడం ఉంది.
అయితే ఈ రోజు కోసం, మేము చేస్తాము మంజూరు కోసం అది పడుతుంది.
నేను ముందుకు మరియు printf వెళ్ళడానికి వెళుతున్న మంచి యూజర్ అనుభవాన్ని కోసం, x.
ఆపై నేను వేచి వెళుతున్న యూజర్ Int పొందండి తో x నాకు ఇవ్వాలని.
>> ఆపై నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు చదరపు x ప్రింట్.
కాబట్టి మీరు ఒక కలిగి ఉన్నప్పుడు కీబోర్డ్, సాధారణంగా ప్రజలు
చిన్న క్యారట్ ఉపయోగించడానికి కీబోర్డ్ పై గుర్తు
అధికారంలోకి ప్రాతినిధ్యం ఆఫ్, లేదా విశేషము.
సో x స్క్వేర్డ్ నేను ఉనికిలో ఉంది.
>> మరియు ఇప్పుడు నేను ఈ చేయ బోతున్నాను.
నేను, x ఏమిటి అలా స్క్వేర్డ్? x వర్గం x సార్లు x.
>> మరియు మేము చేసినది ఈ కొన్ని సమయం క్రితం ఇప్పటికే నేడు.
ఈ భావిస్తాను లేదు అన్ని ఎక్కువ పురోగతి.
నీకు తెలుసా?
యొక్క ఆ ఆలోచన కొన్ని పరపతి లెట్ నైరూప్యత యొక్క చివరిసారి నుండి.
>> అది ఉంటే nice కాదు అనే ఫంక్షన్ ఉంది
ఖచ్చితంగా ఆ చేసే చదరపు?
ఇప్పటికీ ఇది చివరిలో, రోజు, అదే గణిత చేస్తుంది.
కానీ యొక్క నైరూప్య వీలు దూరంగా తీసుకొని ఆలోచన
ఒక సంఖ్య గుణించి మరొక, మరియు కేవలం ఒక పేరు ఇవ్వడం,
వంటి ఈ విలువ చదరపు.
>> మరియు, ఇతర పదాలు లో, సి, యొక్క ఒక ఫంక్షన్ సృష్టించడానికి వీలు
ఖచ్చితంగా ఆ చేసే చదరపు అని.
ఇది చదరపు అనే చేస్తాడు.
ఇది ఒక పూర్ణాంకానికి తీసుకోవాలని జరగబోతోంది.
మరియు మేము చేస్తాము కేవలం రెడీ అప్రమేయంగా, n కాల్.
>> కానీ మేము అది మేము కావలసిన ఏదైనా కాల్ కాలేదు.
మరియు అన్ని అది జరగబోతోంది , సాహిత్యపరంగా, రాబడి
n సార్లు n యొక్క ఫలితం.
కానీ ఎందుకంటే ఏదో తిరిగి, ఇది
మేము చేసిన ఊదా లో కీవర్డ్ ఉంది ఎప్పుడూ లైన్ 11 న, ముందు చూడని, నేను,
కేవలం ఈ సమయంలో గర్జన చెప్పలేము.
>> శూన్యమైన, ఉదాహరణకు మేము ఇప్పుడు చూసిన ముద్రణ పేరు కాకుండా, కేవలం, అనగా
ఏదో ఒకటి చేయి.
కానీ తిరిగి నాకు ఏదో అప్పగిస్తాం లేదు.
ఈ సందర్భంలో, నేను అనుకుంటున్నారు తిరిగి n సార్లు n,
లేదా సంసార, ఆ సంఖ్య.
>> నేను చెప్పలేను, హే, కంప్యూటర్, నేను శూన్యత, ఏదీ తిరిగి.
ఇది ప్రకృతి ద్వారా, తిరిగి, ఒక పూర్ణాంకానికి జరగబోతోంది.
కాబట్టి ఇక్కడ జరగబోతోంది అంతే.
>> చదరపు ఇన్పుట్ ఒక పూర్ణాంకానికి అని అన్నారు.
మరియు మేము దానిని ఉపయోగించవచ్చు కాబట్టి, అది ఉంది ఒక పేరు, ఎన్ ఇది అవుట్పుట్ జరగబోతోంది
ఒక పేరు అవసరం లేని ఒక Int.
మేము ప్రధాన వదిలి చేయవచ్చు, లేదా ఎవరైతే ఈ విలువ మనం ఉంటే గుర్తుంచుకోవడానికి నాకు ఉపయోగించి
దాని సొంత వేరియబుల్ కావలసిన.
>> మరియు, మళ్ళీ, మాత్రమే కొత్త ఇక్కడ కీవర్డ్ రిటర్న్ ఉంది.
మరియు నేను కొన్ని గణిత చేయడం వెబ్.
నేను నిజంగా అనవసరమైన అని అనుకుంటే, నేను Int ఉత్పత్తి గెట్స్ n సార్లు n చెప్పొచ్చు.
>> ఆపై నేను ఉత్పత్తి తిరిగి, చెప్పొచ్చు.
కానీ, మళ్ళీ నా పాయింట్ వెనుకటి ఈ కేవలం ఉండటం మంచి design--
, ఎందుకు ఒక పేరు పరిచయం, ఒక చిహ్నం, ఉత్పత్తి వంటి,
కేవలం వెంటనే తిరిగి ఎలా?
అది కొద్దిగా క్లీనర్ వార్తలు, కొద్దిగా కఠినమైన, కాబట్టి
కేవలం తిరిగి n సార్లు చెప్పడానికి, మాట్లాడటం n, మొత్తంగా ఈ లైన్ వదిలించుకోవటం.
>> మరియు అది చదివి కేవలం తక్కువ కోడ్, తప్పులకు తక్కువ అవకాశం.
మరియు యొక్క ఈ లేదో యొక్క చూసేలా నిజానికి ఇప్పుడు పనిచేస్తుంది.
ఇప్పుడు, నేను వెళ్ళడానికి వెళుతున్న ముందుకు మరియు తిరిగి రావటం జరిగింది.
>> UH-OH, ఫంక్షన్ యొక్క అవ్యక్త ప్రకటన.
నేను ముందు ఏ పెద్ద ఒప్పందం ఈ పొరపాటు.
హైలైట్ నాకు కేవలం టైప్ లెట్, లేదా కాపీ, ఖచ్చితమైన చర్య నమూనా,
లేదా సంతకం ఇక్కడ ఫంక్షన్.
లేదా నేను మొత్తం ఫంక్షన్ తరలించడానికి కాలేదు.
>> కానీ ఒక చిన్న సోమరి ఉంది.
మేము అలా కాదు.
ఇప్పుడు, నాకు తిరిగి తయారు చేద్దాము మళ్ళీ, స్లాష్ తిరిగి డాట్.
>> X 2. x స్క్వేర్డ్ 4. x 3. x స్క్వేర్డ్ 9 ఉంటుంది.
మరియు ఫంక్షన్ తెలుస్తోంది ప్రస్తుతం పనిచేస్తున్నట్లు.
సో వాట్ ఇక్కడ తేడా ఏమిటి?
నేను చదరపు అని ఒక ఫంక్షన్ కలిగి నేను ఒక ఇన్పుట్ లో ఈ కల్పిస్తారు.
నేను ఒక అవుట్పుట్ తిరిగి.
మరియు ఇంకా, గతంలో ఉంటే నేను మరొక ఉదాహరణ తెరవండి
అంతకు ముందు, ఇది prototype.c అని ఉంది
నేను ముద్రణ పేరు, కలిగి మాట్లాడటానికి, గర్జన తిరిగి,
లేదా అది ఏమీ తిరిగి, మరియు కేవలం ఒక ప్రభావాలను.
>> సో వాట్ ఇక్కడ జరగబోతోంది?
బాగా, ఫంక్షన్ పరిగణలోకి కేవలం ఒక క్షణం స్ట్రింగ్ పొందండి.
మేము ఫంక్షన్ ఉపయోగించి పరిష్కరించగలుగుతున్నాము క్రింది విధంగా స్ట్రింగ్ పొందండి.
>> మేము ఒక ఫంక్షన్ ను కలిగి చేసిన స్ట్రింగ్, వంటి, cs50.h ఉన్నాయి
ప్రామాణిక io.h, Int, ప్రధాన, శూన్యమైన ఉన్నాయి.
తర్వాత ప్రతి సమయం నేను చేసిన ఇప్పటివరకు స్ట్రింగ్ పొందండి అని,
నేను అన్నాడు చేసిన వంటి ఏదో స్ట్రింగ్ s స్ట్రింగ్ పొందండి గెట్స్ ఎందుకంటే గెట్ స్ట్రింగ్
ఈ get.c-- స్ట్రింగ్ కాల్ కూడా నేను ఆ ఒక స్ట్రింగ్ తిరిగి
కామా, ఉపయోగించడానికి, మరియు, సే హలో, శాతం లు, బాక్ స్లాష్ n, ఎస్.
>> కాబట్టి ఈ అదే ఉదాహరణ, నిజంగా, మేము ముందుగా ఉందని.
కాబట్టి స్ట్రింగ్ ఒక విలువ తిరిగి పొందండి.
కానీ ఒక క్షణం క్రితం, ముద్రణ స్ట్రింగ్ ఒక విలువ తిరిగి లేదు.
ఇది కేవలం ఒక వైపు ప్రభావం కలిగి ఉంది.
కాబట్టి ఈ ఒక ప్రాథమిక వ్యత్యాసం ఉంది.
మేము వివిధ చూసిన ఇప్పుడు విధులు రకాలు
వీటిలో కొన్ని తిరిగి వచ్చాయి విలువలు, వీటిలో కొన్ని లేదు.
కాబట్టి బహుశా అది స్ట్రింగ్ లేదా Int, లేదా ఫ్లోట్ కాదు.
లేదా ఉండవచ్చు అది కేవలం శూన్యమైన యొక్క.
>> మరియు తేడా ఉంది ఈ విధులను ఆ
డేటా పొందండి మరియు ఒక విలువ తిరిగి నిజానికి పట్టిక తిరిగి ఏదో తెచ్చినందుకు
మాట్లాడటానికి.
కాబట్టి యొక్క ముందుకు వెళ్లి ఒక చివరి సెట్ చూడండి
ఉదాహరణలు స్ఫూర్తిని, ఇప్పుడు, ఇస్తుంది ఆ ఎలా మేము వాటిని, నిజానికి, నైరూప్య మంచి,
మరియు మంచి, మరియు మంచి, లేదా ఎక్కువ, మరియు మరింత, మరియు మరింత, క్రమంలో
రాయడానికి, చివరికి, మంచి కోడ్.
యొక్క ముందుకు వెళ్లి, మరియు ఆత్మ లో తెలియజేయండి స్క్రాచ్, క్రింది వాటిని.
>> నాకు ముందుకు వెళ్లి ఉన్నాయి లెట్ CS50.h మరియు ప్రామాణిక io.h.
నాకు ముందుకు వెళ్లి ఇక్కడ ఇస్తాను నాకు ఒక Int, ప్రధాన, శూన్యమైన.
మరియు నాకు ముందుకు వెళ్లి ఈ cough.c కాల్ తెలియజేయండి.
>> మరియు నాకు ముందుకు మరియు కేవలం వీడలేదు మొదటి, దగ్గు / n ప్రింట్.
నేను ఈ మూడు సార్లు చేయాలనుకుంటున్నారా.
కాబట్టి నేను, వాస్తవానికి, కేవలం జరగబోతోంది కాపీ మరియు మూడు సార్లు పేస్ట్.
నేను ఇప్పుడు తయారు వెళుతున్న డాట్ స్లాష్ దగ్గు దగ్గు.
యొక్క నాకు కొద్దిగా మరింత గది ఇవ్వాలని లెట్ ఇక్కడ, Enter, దగ్గు, దగ్గు, దగ్గు.
>> అక్కడ, వార్తలు స్పష్టంగా, ఇప్పటికే అభివృద్ధి కోసం అవకాశం.
నేను కాపీ మరియు అతికించారు చేసిన కొన్ని సార్లు నేడు.
నేను కాదు కాబట్టి కానీ మాత్రమే ఉంది అనేక అక్షరాలు టైప్ ఉంటుంది.
నేను ఇప్పటికీ మార్చింది కోడ్ యొక్క ఆ పంక్తులు ఉన్నాయి.
>> ఈ మూడు పంక్తులు సమానంగా ఉంటాయి, ఇది సోమరి అనిపిస్తుంది మరియు అవును,
మరియు బహుశా కుడి విధానం కాదు.
సో వాట్ అంశం మేము ఈ కోడ్ పెరుగుతుంది?
మేము కాపీ మరియు పేస్ట్ కోడ్ కలిగి లేదు.
>> మరియు, నిజానికి, మీరు భావిస్తే ఏ సమయంలో మీరే కాపీ మరియు పేస్ట్,
మరియు కూడా కోడ్ మారుతున్న లేదు, అసమానత ఒక మంచి మార్గం ఉంది ఉంటాయి.
మరియు, నిజానికి, ఉంది.
నాకు ముందుకు వెళ్లి లూప్ ఒక చేయండి, అయినప్పటికీ వాక్యనిర్మాణం చేయకపోవచ్చు
ఇంకా సహజంగా వస్తాయి.
>> ఈ మూడు సార్లు, సరళంగా కింది చేయడం ద్వారా
మరియు నేను ఆచరణలో నుండి ఈ తెలుసు జరిగే.
కాని ఇప్పుడు ఉదాహరణలు ఉన్నాయి.
మరియు మీరు చూస్తారు ఆన్లైన్ ఇంకా సూచనలు.
>> ఈ ఆ, లైన్ 6 న వాక్యనిర్మాణం పునరావృత్తం స్క్రాచ్ వంటి చాలా
బ్లాక్, క్రింది మూడు సార్లు పునరావృతం.
ఇది ఇప్పుడు ఒక చిన్న మాయా అనిపిస్తుంది.
కానీ ఈ మరింత పొందుతారు, మరియు మరింత తెలిసిన.
>> మరియు అది పునరావృతం జరగబోతోంది లైన్ ఎనిమిది మూడు సార్లు,
నేను తప్పకుండా మళ్ళీ కంపైల్ అని తయారు దగ్గు, కాబట్టి డాట్ స్లాష్ దగ్గు, దగ్గు, దగ్గు, దగ్గు.
ఇది ఇప్పటికీ అదే విధంగా పనిచేస్తుంది.
కాబట్టి అన్ని జరిమానా మరియు మంచి.
అయితే అది చాలా సంగ్రహమైన కాదు.
>> ఇది ఖచ్చితంగా సరైన.
కానీ అక్కడ అనుకుని ఒక అవకాశం కావచ్చు,
ప్రపంచంలో వంటి స్క్రాచ్ ప్రారంభానికి రకమైన
కాబట్టి ఇక్కడ కొన్ని సెమాంటిక్స్ జోడించడానికి నేను కేవలం, లూప్ కొన్ని లేని,
మరియు ఈ ఒక ఫంక్షన్ చెప్పారు దగ్గు, లేదా దగ్గు లేదు.
నీకు తెలుసా?
నాకు ఒక ఉండాలి ప్రయత్నించండి లెట్ కంటే కొద్దిగా చల్లగా,
మరియు నిజానికి ఒక ఫంక్షన్ వ్రాసే కొన్ని దుష్ప్రభావాలు ఉంది, అది దగ్గు కాల్.
>> మరియు అది ఏ ఇన్పుట్ పడుతుంది, మరియు అవుట్పుట్ గా విలువ తిరిగి.
కానీ మీరు అది ఏమి తెలుసు?
ఇది దీన్ని printf చేస్తుంది కోట్ unquote, దగ్గు.
>> ఇప్పుడు ఇక్కడ, నేను వెళుతున్న ముందుకు మరియు Int కోసం వెళ్ళడానికి,
నేను ప్లస్ ప్లస్ సున్నా గెట్స్, నేను 3 కంటే తక్కువ.
నేను ఇది printf చేయరు వెళుతున్న నిస్సందేహంగా ఒక తక్కువ స్థాయి అమలు
వివరాలు.
నేను దగ్గు ఎలా పట్టించుకోను.
నేను దగ్గు ఫంక్షన్ ఉపయోగించాలనుకుంటున్నాను.
నేను కేవలం దగ్గు కాల్ వెళుతున్న.
>> ఇప్పుడు, వైరుధ్యాన్ని గమనిస్తారు.
మీరు లేకపోతే మీరు ఒక ఫంక్షన్ కాల్ చేసినప్పుడు అది ఇన్పుట్లను పూర్తిగా మంచిది ఇవ్వాలనుకున్న.
కేవలం ఓపెన్ బ్రాకెట్, దగ్గరగా బ్రాకెట్, మరియు మీరు పూర్తి చేసిన.
>> మీరు ఒక ఫంక్షన్ నిర్వచించే సమయంలో, లేదా ఒక ఫంక్షన్ యొక్క నమూనా ప్రకటించి,
మీరు ముందుగానే తెలిసి ఉంటే అది కాదు ఏ వాదనలు తీసుకుంటున్నానని,
ఆ కుండలీకరణాల్లో తప్ప సే.
మరియు ఆ కొన్ని చేస్తుంది మీరు ఆ అనుకోకుండా అది దుర్వినియోగం కాదు.
నాకు ముందుకు వెళ్లి దగ్గు తయారు చేద్దాము.
మరియు, కోర్సు యొక్క, నేను ఒక తప్పు చేసాను.
>> డ్యామిట్, అక్కడ అవ్యక్త ప్రకటన.
కానీ ఆ మంచిది.
ఇది ఒక సులభమైన పరిష్కారం ఉంది.
నేను నమూనా కేవలం అధిక అప్ అవసరం నేను దీన్ని ఉపయోగించి చేస్తున్నాను కంటే నా ఫైలులో.
>> కాబట్టి ఇప్పుడు నాకు దగ్గు మళ్ళీ, nice తయారు చేద్దాము.
ఇప్పుడు, అది పనిచేస్తుంది.
దగ్గు, దగ్గు, దగ్గు, చేయండి.
కాబట్టి మీరు మేము నిజంగా అని అనుకుంటున్నాను ఉండవచ్చు కేవలం ఈ సమస్య ఇంజనీరింగ్.
మరియు, నిజానికి, మేము ఉన్నాయి.
ఈ మంచి కాదు కార్యక్రమంలో అభ్యర్థి
కోసం సమయంలో పునఃనిర్మాణానికి, మరియు ఏమి చేయడం
క్రమానుగత కుళ్ళిన అని, ఇక్కడ మీరు కొన్ని కోడ్, మరియు తర్వాత
మీరు అంశం విషయాలను రకమైన, కాబట్టి వారికి మరింత సెమాంటిక్స్ ఆపాదించు కు,
చివరికి దీర్ఘకాల పనులను తిరిగి.
కానీ వైపు ఒక భవనం బ్లాక్ మరింత అధునాతన కార్యక్రమాలు
మనం మొదలవుతాయని ముందు కాలం అని వ్రాయడం
మాకు పదజాలం కలిగి అనుమతిస్తుంది ఇది మంచి కోడ్ రాయడానికి.
మరియు, నిజానికి, యొక్క లేదో యొక్క చూసేలా మన మరింత ఈ సాధారణీకరించడం కాదు.
>> ఇది కొంచెం మందకొడిగా అనిపిస్తున్న నేను, ప్రధాన, లూప్ ఈ రంధ్రాన్ని సరి చేయు గురించి ఆందోళన అవసరం,
మళ్లీ మళ్లీ దగ్గు కాల్.
నేను కేవలం దగ్గు చెప్పలేదు, మూడు సార్లు దగ్గు దయచేసి?
ఇతర మాటలలో, ఎందుకు నేను కాదు కేవలం దగ్గు మరియు దీన్ని ఇన్పుట్ ఇవ్వాలని?
>> నేను కేవలం చెప్పలేను లో ప్రధాన దగ్గు మూడు సార్లు.
ఇప్పుడు, ఈ మాయా యొక్క రకం.
ఇది ఇక్కడ పునరుత్థాన వార్తలు.
మరియు అది, నిజానికి ఒక శిశువు దశ.
>> కానీ కేవలం సామర్థ్యం చెప్పాలని లైన్ ఎనిమిది, మూడు సార్లు దగ్గు,
ఇది కేవలం చాలా చదవదగ్గ వార్తలు.
మరియు, ప్లస్, నాకు తెలుసు లేదు లేదా ఎలా దగ్గు అమలవుతుంది శ్రద్ధ.
మరియు, నిజానికి, తర్వాత కాల మరియు చివరి ప్రాజెక్టులకు,
మీతో ప్రాజెక్ట్ అధిగమించేందుకు ఉంటే ఒక క్లాస్మేట్ లేదా రెండు సహచరుల,
మీరు చూడాలని అని తెలుసుకోవటం చేస్తాము కలిగి, లేదా, పని విభజించడానికి కావలసిన.
>> మరియు మీరు మార చూడాలని ముందుగానే, ఎవరు ఏమి చేస్తాడు,
మరియు ముక్కలు?
మరియు అది nice కాదు మీరు, ఉదాహరణకు,
రచన ప్రధాన బాధ్యతలు పూర్తి పడుతుంది.
మరియు మీ సహవాసి లేదా మీ భాగస్వామి మరింత సాధారణంగా,
దగ్గు అమలు జాగ్రత్త తీసుకుంటుంది.
>> మరియు ఈ విభజన, ఈ నైరూప్యత యొక్క గోడలు,
లేదా నైరూప్యత యొక్క పొరలు ఉంటే మీరు సూపర్ శక్తివంతమైన ఉన్నాయి ఉంటుంది,
ముఖ్యంగా పెద్ద ఎందుకంటే సంక్లిష్ట కార్యక్రమాలు మరియు వ్యవస్థలు,
అది నిర్మించడానికి అనేకమందిని అనుమతిస్తుంది విషయాలు కలిసి, చివరకు
ఈ విధంగా వారి పని కలిసి కుట్టు.
కానీ, వాస్తవానికి, మేము ఇప్పుడు దగ్గు పరిష్కరించడానికి అవసరం.
మేము దగ్గు చెప్పడం అవసరం ఆ, హే, మీరు ఏమి?
మీరు ఒక తీసుకోవాలని అవసరం చూడాలని ఇన్పుట్గా కాబట్టి రద్దు కాదు, కానీ పూర్ణాంకానికి మరియు ఇప్పుడు.
యొక్క ముందుకు వెళ్లి ఉంచి లెట్ పూర్ణాంకానికి దగ్గు. నేను సున్నా పొందుతాడు.
>> నేను ఎన్ని సార్లు కంటే తక్కువగా ఉంటుంది.
నేను ముందు మూడు తెలిపారు.
కానీ నేను ఏమి కాదు.
నేను సాధారణీకరణం వరకు దగ్గు అనుకుంటున్నారా నిద్రావస్థ ఎన్ని మద్దతు.
>> అందువలన, నిజానికి, అది నేను కావలసిన n, ఏ యూజర్ నాకు చెబుతుంది.
ఇప్పుడు, నేను ముందుకు వెళ్లి ప్రింట్ దగ్గు చెప్పగలను.
ఉన్నా ఏమి సంఖ్య వినియోగదారు లో పోయినప్పుడు,
నేను చాలా సార్లు iterate ఉంటుంది.
>> కాబట్టి రోజు చివరిలో, కార్యక్రమం ఒకే విధంగా ఉంటుంది.
కానీ ఈ విషయాన్ని గమనించి ఇతర ఫైల్ కావచ్చు.
నిజానికి, నేను తెలియదు క్షణం ఎలా printf అమలు చేయబడుతుంది.
>> ఆ సమయంలో తెలియదు ఎలా పొందాలో స్ట్రింగ్ లేదా Int పొందండి, లేదా ఫ్లోట్ పొందుటకు
అమలు చేయబడతాయి.
నేను వద్దు నా తెరపై వాటిని చూడండి.
ఇది ఉంది, నేను దృష్టి మొదలు వెబ్ నా ప్రోగ్రామ్, ఆ విధులు.
>> అందువలన, నిజానికి, వెంటనే మీకు గా ఈ వంటి కోడ్ కారక ప్రారంభించడానికి,
మేము కూడా దగ్గు తరలించడానికి కాలేదు ఒక ప్రత్యేక ఫైలు ఎలా?
ఎవరో అది అమలు కాలేదు.
మరియు మీరు మరియు మీ ప్రోగ్రామ్ మారింది చాలా అందమైన, మరియు చాలా రీడబుల్,
నిస్సందేహంగా, నిజంగా నాలుగు అక్కడే లైన్ కార్యక్రమ.
>> కాబట్టి యొక్క ఇప్పుడు ముందుకు తెలియజేయండి మరియు ఒక మరింత మార్పు.
గమనించి ఆ నా నమూనా టాప్ మార్చడానికి ఉంది.
కాబట్టి నాకు అలా పరిష్కరించండి నేను కోప్పడ్డాడు పొందలేము.
>> దగ్గు చేయండి, నాకు ఒకసారి దగ్గు అమలు అనుమతిస్తాయి మరింత ఇప్పటికీ అదే పనిని.
కానీ ఇప్పుడు, మేము ఒక కలిగి గమనించవచ్చు ఒక చివరి వెర్షన్ కోసం పదార్ధం.
నీకు తెలుసా?
నేను తప్పనిసరిగా కేవలం దగ్గు వద్దు.
నేను మరింత సాధారణ ఏదో కావాలి.
కాబట్టి మీరు ఏమి?
నేను దీన్ని చేయాలనుకుంటున్నారా.
నేను కలిగి, చాలా స్క్రాచ్ వంటి కావలసిన స్త్రేస్ సే బ్లాక్, కాని కేవలం
ఏదో సార్లు కొన్ని సంఖ్య చెప్పటానికి.
నేను ఒక నిర్దిష్ట స్ట్రింగ్ అంతరంలో.
మరియు, అందువలన, నాదగ్గర అది కేవలం దగ్గు అంతరంలో.
నేను చెప్పటానికి కావలసిన స్ట్రింగ్ లో ముగిసింది.
>> నోటీసు సో, నేను సాధారణీకరణం చేసిన ఈ కాబట్టి ఇప్పుడు ఆ
సే మంచి పేరు అనుకుని ఈ కోసం, మొదటి,
స్క్రాచ్ వలె కాకుండా, రెండు వాదనలు పడుతుంది.
ఒక స్ట్రింగ్.
ఒక Int ఉంది.
>> నేను వారిని మారవచ్చు.
ఆలోచన వంటి నేను రకమైన మొదటి స్ట్రింగ్ సే తరువాత
ఎన్ని సార్లు తరువాత.
వాయిడ్ ఇప్పటికీ అర్థం ఏదైనా తిరిగి లేదు.
ఈ కేవలం దృశ్య వైపు ఉంటాయి ప్రభావాలు [లాగే? జోర్డాన్,?]
పదాన్ని శబ్ద వైపు ప్రభావం.
ఇది ఇప్పటికీ ఏదో n సార్లు చేస్తుంది వరకు 0, అయితే n సమానం కాదు.
ఈ n మొత్తం సార్లు అర్థం.
ఆపై కేవలం ప్రింట్ సంసార స్ట్రింగ్.
నేను నిజంగా సాధారణీకరణం చేసిన కోడ్ యొక్క ఈ లైన్.
కాబట్టి ఇప్పుడు, నేను ఎలా అమలు చెయ్యాలి దగ్గు ఫంక్షన్?
>> నేను గర్జన దగ్గు చేయవచ్చు.
మరియు నేను ఇప్పటికీ పడుతుంది ఎలా మీరు దగ్గు కావలసిన అనేక సార్లు.
కానీ మీరు ఏమి?
నేను ఇప్పుడు చెప్పండి రౌడీ చేయవచ్చు.
>> నేను చెప్పిందే కాల్ చేయవచ్చు పదం దగ్గు, n అక్కడ.
నేను కూడా అమలు అనుకుంటే, కేవలం వినోదం కోసం, ఒక తుమ్ము ఫంక్షన్,
నేను సార్లు కొన్ని సంఖ్య తుమ్ము చేయవచ్చు.
మరియు నేను ఎందుకంటే, తిరిగి n ఉంచుకోవచ్చు ఈ సందర్భంలో లేదా దర్శిని ఆ మీటర్ల గమనించవచ్చు
ఈ ఫంక్షన్ లో మాత్రమే ఉంది.
>> మరియు n ఈ సందర్భంలో మాత్రమే ఇక్కడ ఈ ఫంక్షన్ లోపల ఉంది.
కాబట్టి మేము తిరిగి వచ్చి చేస్తాము స్కోప్ ఈ సమస్యలు.
మరియు ఇక్కడ, నేను చెప్పడానికి వెళుతున్న అఛూ, ఆపై n సార్లు, సెమీ కోలన్.
>> మరియు ఇప్పుడు, నేను కేవలం ఋణం అవసరం ఈ ఫంక్షన్ ఇక్కడ సంతకాలు.
కాబట్టి దగ్గు సరైనది.
వాయిడ్ తుమ్ము ఇప్పుడు సరైనది.
>> మరియు నేను ఇప్పటికీ కేవలం చెప్పటానికి అవసరం.
నేను సే, చెప్పడానికి వెళుతున్నాను స్ట్రింగ్ s, Int n, సెమీ కోలన్.
నేను చేసిన ఎక్కువ ఇంజనీర్డ్ ఈ కార్యక్రమం యొక్క హెక్.
>> మరియు ఈ లేదు తప్పనిసరిగా ఈ అర్థం
రాసేటప్పుడు మీరు ఏమి చెయ్యాలి కార్యక్రమాలను కూడా సరళమైన.
స్పష్టమైన ఏదో తీసుకోండి నిజంగా, సాధారణ, నిజంగా చిన్నది
మరియు అది తిరిగి ప్రవేశపెట్టాలని చాలా మార్గం కోడ్ ఉపయోగించి.
కానీ మీరు నిజంగా చూసే, మరియు చేస్తాము సమయం ఈ ఉదాహరణలు తిరిగి చూడండి,
మరియు గ్రహించడం, OH, ఆ దశలు మేము నిజంగా సాధారణీకరించడం పట్టింది,
ఏదో కారణం, రోజు చివరిలో వరకు
నా కోడ్ వాస్తవానికి చాలా సమంజసమైన ఉంది.
నేను మూడు దగ్గు అనుకుంటే ఎందుకంటే టైమ్స్ తర్వాత మూడు సార్లు తుమ్ము,
నేను కేవలం ఈ తిరిగి వెళుతున్న కార్యక్రమం దగ్గు తయారు, మరియు దగ్గు అమలు.
నేను మూడు దగ్గుకు కలిగి మరియు మూడు తుమ్ములు.
>> కాబట్టి ఈ ఒక ప్రాథమిక ఉంది రూపావళి, మీరు రెడీ ఉంటే,
మేము గురించి వెళ్ళవచ్చు ఎలా అసలైన కార్యక్రమం అమలు.
కానీ మనం అది ఇప్పుడు ఏమి వీలు మేము ఈ సమయంలో ఇవన్ని చేసిన
మరియు చివరి ముక్కలు కొన్ని ఈ సాధారణ ఆదేశం వెనుక ఉన్నాయి.
రోజు ముగింపులో, మేము చేసిన మా కంపైలర్ వంటి గణగణమని ద్వని చేయు ఉపయోగించి.
మేము సోర్స్ రాయడం చేసిన కోడ్, అది మార్చే
యంత్రం కోడ్ లోకి గణగణమని ద్వని చేయు ద్వారా.
>> మరియు మేము ఉపయోగించి పరిష్కరించగలుగుతున్నాము కేవలం చేయండి మన కీస్ట్రోక్ సులభతరం
మేము గుర్తు లేని గణగణమని ద్వని చేయు యొక్క ఆ మంత్రోచ్చాటనల.
కానీ నిజానికి చేయండి ఏమి ఉంది?
మరియు, క్రమంగా, ఏమిటి గణగణమని ద్వని చేయు వాస్తవానికి చేయడం?
>> సరళీకృతం చేసిన అయితే, అది అవుతుంది, చెప్పి నేటి చర్చ,
మీరు సోర్స్ కోడ్ పడుతుంది ఇది దాటిన మీరు ఇస్తుంది ఇది ఒక కంపైలర్, ఇన్పుట్
యంత్రం యొక్క అవుట్పుట్ కోడ్, అక్కడ బయటకు వస్తాడు
అక్కడ లోపల కొన్ని వివిధ దశలను.
మరియు కంపైల్ గొడుగు నిర్మాణము దశలను యొక్క మొత్తం బంచ్ ఉపయోగించే పదం.
కానీ ఇంకా బాధించటం తెలియజేయండి ఈ నిజంగా త్వరగా.
>> ఇది మేము చేస్తున్న చేసిన అవుతుంది నేను ఒక కార్యక్రమం అమలు ప్రతిసారీ మరింత విషయాలు,
లేదా ప్రతిసారి నేను ఈ రోజు ఒక కార్యక్రమం కంపైల్.
కాబట్టి preprocessing సూచిస్తుంది ఒక సి కార్యక్రమం ఏదైనా దీన్ని,
మేము మళ్ళీ మళ్ళీ చూస్తారు వంటి, ఆ, ఈ హాష్ చిహ్నం మొదలవుతుంది
లేదా ఇక్కడ హాష్ ట్యాగ్ చిహ్నం, అంటే అది ఒక ప్రాసెసర్ ఆదేశం ఉంది.
ఈ సందర్భంలో, అంటే, హే కంప్యూటర్, ఈ ఫైలు ఏదో ఒకటి చేయాలని
మీరు నిజంగా నా స్వంత కోడ్ కంపైల్ ముందు.
>> ఈ సందర్భంలో, హాష్ ఉన్నాయి, ముఖ్యంగా, చెప్పడం C యొక్క మార్గం,
హే కంప్యూటర్, విషయాలు పొందండి వెళ్ళండి Cs50.h యొక్క మరియు వాటిని ఇక్కడ అతికించండి.
హే కంప్యూటర్, అది పొందుటకు వెళ్ళండి ప్రామాణిక io.h యొక్క విషయాలు
ఆ ఎంతవరకూ హార్డు డ్రైవు, ఇక్కడ అతికించండి.
కాబట్టి ఆ విషయాలు ఏమి preprocessing సమయంలో మొదటి.
>> మరియు గణగణమని ద్వని చేయు మాకు ఈ అన్ని చేస్తుంది.
మరియు అది రంధ్రాన్ని సరి చేయు అది ఫాస్ట్, మీరు కూడా లేదు
జరుగుతున్న నాలుగు విభిన్న విషయాలు చూడండి.
కానీ ఆ మొదటి అటువంటి అడుగు.
>> నిజానికి ఏం తదుపరి జరుగుతుంది?
బాగా, తదుపరి అధికారిక దశల కంపైల్ ఉంది.
మరియు ఆ అవుతుంది ప్రోగ్రాం కంపైల్
సాంకేతికంగా నుండి వెళుతున్న అంటే సోర్స్ కోడ్, మేము చేసిన విషయాన్ని
జరిగింది ఏదో, నేడు రాయడం అసెంబ్లీ కోడ్ అంటారు, ఏదో
ఒక చిన్న వ్యత్యాసంతో ఉంటుంది.
>> మరియు, నిజానికి, మేము ఈ నిజమైన ఫాస్ట్ చూడగలరు.
నాకు నిజంగా నా IDE లోకి వెళ్ళి తెలపండి.
నాకు ముందుకు వెళ్లి తెరుచుకుంటాయి hello.c వెళ్ళి తెలపండి, ఇది మొట్టమొదటి కార్యక్రమం తో మేము
బుధవారం ప్రారంభమైంది.
మరియు నాకు ముందుకు వెళ్లి గణగణమని ద్వని చేయు ఒక అమలు అనుమతిస్తాయి విభిన్నంగా కొద్దిగా, గణగణమని ద్వని చేయు s, hello.c,
నిజానికి అన్నారు నాకు మరొక ఫైల్ hello.s ఇస్తాయి.
>> మరియు మేము ఎప్పుడూ బహుశా మళ్ళీ కోడ్ యొక్క ఈ రకమైన చూడవచ్చు.
మీరు ఒక తక్కువ స్థాయి తీసుకోకపోతే CS61 వంటి వ్యవస్థలు తరగతి,
మీరు మరింత చాలా చూస్తారు కోడ్ యొక్క ఈ రకమైన.
కానీ ఈ అసెంబ్లీ భాష.
ఈ x86 అసెంబ్లీ లాంగ్వేజ్ ఆ మూలమైన ఉంది CPU
CS50 IDE నిజానికి అర్థం.
>> మరియు అది వంటి నిగూఢ చూడండి, అది ఏదో ఉంది
కంప్యూటర్ అందంగా బాగా అర్థం.
సబ్ q, ఈ తీసివేసినప్పుడు ఉంది.
ఉద్యమాలు ఉంది.
>> ఇక్కడ విధులు ఉన్నాయి కాల్ x oring ఒక ఉద్యమం, ఒక అనుబంధాన్ని, ఒక పాప్,
తిరిగి.
సో అక్కడ కొన్ని చాలా తక్కువ స్థాయి సూచనలను
CPU లు అర్థం నేను ముందుగా పేర్కొన్నట్లు.
ఆ ఏమి ఇంటెల్ ఇన్సైడ్ ఉంది.
>> నమూనాలు ఉన్నాయి సున్నాలు మరియు వాటిని ఆ
ఈ arcanely మాటలతో మ్యాప్, కానీ కొంతవరకు బాగా పేరు, సూచనలను,
మాట్లాడటానికి.
ఆ ఏమి జరుగుతుందనే మీరు మీ కోడ్ కంపైల్.
మీరు అసెంబ్లీ పొందండి అది బయటకు భాష,
మూడో మెట్టు సమీకరించటానికి ఉంది అంటే అసెంబ్లీ కోడ్ లోకి, చివరికి,
యంత్రం ఉంటుంది కోడ్ సున్నాలు మరియు వాటిని, కాదు మేము కేవలం ఒక క్షణం క్రితం చూసిన టెక్స్ట్.
>> కాబట్టి ముందు ప్రాసెసింగ్ అనిపించలేదని మరియు భర్తీ మరియు కొన్ని ఇతర విషయాలు.
సేకరించి మీ సోర్స్ పడుతుంది సి నుండి కోడ్, సోర్స్ కోడ్
మన అసెంబ్లీలో వ్రాసాడు మేము కేవలం నచ్చావు కోడ్.
అసెంబ్లింగ్ అసెంబ్లీ పడుతుంది సున్నాల మరియు వాటిని కోడ్
CPU నిజంగా రెడీ ఆ రోజు చివరిలో అర్థం.
మరియు లింకింగ్ చివరి దశలో ఉంది ఆ us-- జరుగుతుంది మళ్ళీ,
కాబట్టి వేగంగా మేము కూడా లేదు అని చెప్పాడు నోటీసు,
హే కంప్యూటర్, అన్ని పడుతుంది సున్నాలు మరియు వాటిని ఆ
డేవిడ్ యొక్క కోడ్ కంపైల్ ఫలితములు, మరియు ఈ సందర్భంలో తన ప్రధాన విధి.
>> మరియు హే కంప్యూటర్, పొందండి వెళ్ళండి సున్నాలు మరియు వాటిని అన్ని
CS50 సిబ్బంది రాశాడు CS50 లైబ్రరీ లోపల.
డేవిడ్ యొక్క ఆ కలపాలి.
మరియు హే కంప్యూటర్, అన్ని సున్నాలు పొందండి వెళ్ళండి మరియు ఇతరుల సంవత్సరాల వ్రాసిన వాటిని ఆ
printf కోసం క్రితం.
మరియు ఆ జోడించవచ్చు మొత్తం విషయం, కాబట్టి మేము చేసిన
నా సున్నాలు మరియు వాటిని, వచ్చింది CS50 సిబ్బంది యొక్క సున్నాలు మరియు వాటిని,
printf సున్నాలు మరియు వాటిని, మరియు ఏదైనా మేము ఉపయోగిస్తున్న.
>> వారు అన్ని ఒక లోకి కలిసి పెట్టడానికి కార్యక్రమం ఈ సందర్భంలో అని, హలో.
కేవలం కాబట్టి ఇకమీదట మేము, పదం సేకరించి ఉపయోగించండి.
మరియు మేము మంజూరు కోసం పడుతుంది చేసినప్పుడు ఆ దాని అర్థం మేము మీ ప్రోగ్రామ్ కంపైల్ చెప్పేది,
హే ముందు ప్రాసెసింగ్ చేయండి కలపడం మరియు కలుపుతుంది.
కానీ వాస్తవానికి కొన్ని జ్యుసి విషయాలు అనిపిస్తుంది హుడ్ కింద జరగబోతోంది.
మరియు ముఖ్యంగా మీరు ఉంటే ఆసక్తికరమైన కొంత సమయం పొందుటకు,
మీరు poking ప్రారంభించవచ్చు ఈ దిగువ స్థాయిలో చుట్టూ.
కానీ ఇప్పుడు కోసం, రియలైజ్ నేడు అవేలు మధ్య
కేవలం చాలా ఉన్నాయి ఒక ప్రక్రియ ప్రారంభం,
సౌకర్యవంతంగా పొందే హలో వరల్డ్ అలాంటిదే.
నిజానికి, మేము నేడు ఏమి అత్యంత ఖచ్చితంగా సూపర్ ఫాస్ట్ మునిగిపోతుంది కాదు.
మరియు అది కొన్ని పడుతుంది సమయం, మరియు కొన్ని ఆచరణ.
మరియు అసమానత, మీరు క్రమం మీ కీబోర్డ్ నొక్కండి మీరు
లేదా స్క్రీన్ మీద అరుస్తుంటారు.
మరియు ఆ యొక్క సరే.
అయితే, బహుశా కాదు ప్రయత్నించండి చాలా లైబ్రరీ లో చేస్తున్నాయి.
>> చివరకు, మీరు చేస్తాము అయితే చేయగలరు, ప్రారంభించడానికి ఉంటుంది
మంచి కోడ్ లో రెండు, నమూనాలను చూసిన మీరు రాసిన చేసిన తప్పులను లో
మీరు చేసిన.
మరియు ప్రక్రియ లాగానే ఒక TF కావడానికి లేదా సిఏ వంటిది,
మీరు మంచి పొందుటకు ప్రారంభించగలరు మరియు ఆ నమూనాలు చూడటంతో మంచి,
మరియు కేవలం మీ పరిష్కార చివరికి సొంత సమస్యలు.
ఈలోగా, అక్కడ పుష్కలంగా ఉంటుంది మనలో మీరు మద్దతు కల్పించడానికి, మరియు మీరు పొందుటకు
ఈ ద్వారా.
మరియు వ్రాయడం అప్లను అన్ని సమస్యలకు కోసం
మీరు ద్వారా మార్గనిర్దేశం చేస్తుంది ఆదేశాలన్నిటిని
నేను ఖచ్చితంగా తెలుసు ఇప్పుడు ద్వారా ఆచరణలో చాలా,
కానీ ఎగుర ఉండవచ్చు ఇప్పుడు ఒకరి తలపై.
మరియు ఆ పూర్తిగా మంచిది.
>> కానీ, చివరికి, మీరు వెళుతున్న విధానాలను ఉద్భవించి చూడడానికి.
మరియు మీరు అన్ని గత పొందడానికి స్టుపిడ్ వివరాలను, కుండలీకరణాలు వంటి,
మరియు గిరజాల జంట కలుపులు, మరియు సెమీ కోలన్, మరియు stuff, స్పష్టముగా,
అన్ని వద్ద కాదు తెలివైన ఆసక్తికరమైన.
మరియు అది లక్ష్యం కాదు ఏ పరిచయ తరగతి తీసుకొని.
ఇది పట్టింపు మాత్రం చేసిన ఆలోచనలు వార్తలు.
>> ఇది ఉచ్చులు, మరియు పరిస్థితులు, మరియు విధులు
మరియు మరింత శక్తివంతంగా నైరూప్యత, మరియు కోడ్ కారక,
మరియు మంచి డిజైన్, మరియు మంచి శైలి, మరియు చివరికి సవ్యత
మీ కోడ్, ఆ చివరికి అత్యంత పట్టింపు మాత్రం.
కాబట్టి వచ్చే వారం, మేము ఈ పడుతుంది మేము మొదటి స్క్రాచ్ చూసిన ఆలోచనలు
మరియు ఇప్పుడు అనువాదం చేశారు సి మరియు మేము ప్రారంభిస్తాము
మొదటి పరిచయం కోర్సు యొక్క నిజమైన ప్రపంచంలో డొమైన్లు.
>> మేము భద్రత ప్రపంచ దృష్టి చేస్తాము, మరియు మరింత ప్రత్యేకంగా, గూఢ లిపి శాస్త్రానికి
సమాచారం స్క్రాంబ్లింగ్ యొక్క కళ.
మొదటి మధ్య మరియు మీరు సమస్యలు మీరే
దాటి రాయడానికి పొందుతారు వాక్యనిర్మాణం యొక్క కొన్ని ఆడటం
మరియు కొన్ని తార్కిక పరిష్కార సమస్యలు, చిట్టచివరకు, దీర్ఘ ముందు,
వాస్తవానికి పోవు, లేదా గుప్తీకరించడానికి ఉంది, మరియు చివరికి వ్యక్తీకరించడానికి సమాచారం.
మరియు ప్రతిదీ మేము చేసిన నేడు, బొత్తిగా తక్కువ రెడీ
స్థాయి అని చెప్పడానికి అనుమతిస్తుంది అన్నారు మాకు ఒకటి, మరియు తీసుకోకూడదని,
మరియు పైన వైపు ఒక అడుగు మరింత ఇంకా చాలా ఆసక్తికరమైన కోడ్ రాయడం.
>> ఆ తర్వాత వారం సో మరింత.
>> [వీడియో ప్లేబ్యాక్]
>> దాన్ని గురించి నాకు తెలియజేయవచ్చు చివరిసారి మీరు అతనిని చూసిన?
దాన్ని నేను నిజంగా చెప్పగలదు?
నా ఉద్దేశ్యం, అది ఏ ఇతర వంటి ఉంది ప్రీ ప్రొడక్షన్ సాధన,
ఏదో ఉంది తప్ప అతను చెప్పాడు నాతో కష్టం అని చాలా చివరిలో.
>> -ఈ CS50 ఉంది.
>> -ఆ ఒక కట్ ఒక్కరూ వార్తలు, రిహార్సల్ మీద గొప్ప ఉద్యోగం.
>> -ఆ భోజన?
>> అవును, మీరు మరియు నేను ఒక బిట్ లో ఒక శాండ్విచ్ పట్టుకొను.
నాకు కేవలం debrief లెట్ డేవిడ్ నిజంగా త్వరగా.
డేవిడ్?
>> [END ప్లేబ్యాక్]