
Arabic: 
 >> [عزف موسيقى] 
 >> دوغ لويد: نحن هنا. 
 ربما يكون هذا هو الموضوع الأكثر صعوبة 
 التي نتحدث عنها في CS50. 
 وإذا كنت قد قرأت أي شيء عن المؤشرات 
 قبل أن تكون مخيفًا قليلاً للذهاب إلى هذا الفيديو. 
 صحيح أن المؤشرات تسمح لك بالقدرة 
 ربما تفسد بشدة عندما تكون 
 العمل مع المتغيرات والبيانات والتسبب في تعطل البرنامج. 
 لكنها مفيدة حقًا وتتيح لنا طريقة رائعة حقًا 
 لتمرير البيانات ذهابًا وإيابًا بين الوظائف ، 
 التي لا نستطيع القيام بها. 
 >> وما نريد فعله هنا هو التدريب 
 يجب أن يكون لديك انضباط جيد للمؤشر ، بحيث يمكنك استخدام المؤشرات بشكل فعال 
 لجعل برامجك أفضل بكثير. 
 كما قلت ، تعطينا المؤشرات طريقة مختلفة لتمرير البيانات بين الوظائف. 
 الآن إذا كنت تتذكر من فيديو سابق ، متى 
 ذكرت أننا كنا نتحدث عن نطاق متغير 

Korean: 
 >> [음악 재생] 
 >> DOUG LLOYD : 포인터, 여기 있습니다. 
 이것은 아마도 가장 어려운 주제가 될 것입니다 
 우리는 CS50에서 이야기합니다. 
 그리고 포인터에 대해 읽은 적이 있다면 
 이 비디오를 보는 데 약간의 위협이 될 수 있습니다. 
 포인터가 당신에게 능력을 허용한다는 것은 사실입니다 
 당신이있을 때 아마 아주 심하게 망쳐 
 변수 및 데이터 작업 및 프로그램 작동 중단 
 그러나 그들은 실제로 정말 유용하고 우리에게 정말 좋은 방법을 허용합니다 
 함수간에 데이터를주고 받음 
 그렇지 않으면 우리는 할 수 없습니다. 
 >> 우리가 정말로하고 싶은 것은 기차입니다 
 당신은 포인터를 효과적으로 사용할 수 있도록 훌륭한 포인터 훈련을 받아야합니다. 
 당신의 프로그램을 훨씬 더 좋게 만들기 위해. 
 내가 말했듯이 포인터는 함수간에 데이터를 전달하는 다른 방법을 제공합니다. 
 이전 비디오를 기억하면 
 우리는 가변 범위에 대해 이야기하고있었습니다. 

Hindi: 
 >> [संगीत खेल] 
 >> डब्लू एलओवाईवाईडी: संकेत, यहां हम हैं। 
 यह शायद सबसे कठिन विषय होने जा रहा है 
 हम CS50 के बारे में बात करते हैं। 
 और अगर आपने पॉइंटर्स के बारे में कुछ भी पढ़ा है 
 इससे पहले कि आप इस वीडियो में जाने से थोड़ा डरें। 
 यह सच है कि संकेत आपको क्षमता प्रदान करते हैं 
 शायद जब आप बहुत बुरी तरह से पेंच कर रहे हैं 
 चरों और डेटा के साथ काम करना, और आपके प्रोग्राम को क्रैश करने का कारण बनता है। 
 लेकिन वे वास्तव में उपयोगी हैं और वे हमें एक बहुत अच्छा तरीका है 
 फ़ंक्शन के बीच डेटा को आगे और पीछे करने के लिए, 
 अन्यथा हम ऐसा करने में असमर्थ हैं। 
 >> और इसलिए हम वास्तव में यहाँ क्या करना चाहते हैं ट्रेन है 
 आपके पास अच्छा पॉइंटर अनुशासन है, ताकि आप पॉइंटर्स का प्रभावी ढंग से उपयोग कर सकें 
 अपने कार्यक्रमों को बेहतर बनाने के लिए। 
 जैसा कि मैंने कहा कि पॉइंटर्स हमें फंक्शन्स के बीच डेटा पास करने का एक अलग तरीका देते हैं। 
 अब अगर आप पहले वाले वीडियो से याद करते हैं, तो कब 
 हम चर दायरे के बारे में बात कर रहे थे, मैंने उल्लेख किया है 

Chinese: 
 >> [音樂播放] 
 >> DOUG LLOYD：指針，到了。 
這可能是最困難的話題
我們在CS50中談到的
如果您已閱讀有關指針的任何內容
然後您可能會有點害怕這個視頻。 
的確，指針確實允許您
可能會嚴重破壞您
使用變量和數據，並導致程序崩潰。 
但是它們實際上是非常有用的，它們使我們有一個非常好的方法
在功能之間來回傳遞數據， 
否則我們無法做到。 
 >>所以我們這裡真正想做的是火車
您要有良好的指針紀律，以便可以有效地使用指針
使您的程序更好。 
正如我所說的，指針為我們提供了一種在函數之間傳遞數據的不同方法。 
現在，如果您回想起之前的視頻， 
我說的是可變範圍

Dutch: 
 >> [MUZIEK SPELEN] 
 >> DOUG LLOYD: Pointers, hier zijn we. 
 Dit wordt waarschijnlijk het moeilijkste onderwerp 
 waar we het over hebben in CS50. 
 En als je iets hebt gelezen over aanwijzers 
 voordat je misschien een beetje intimiderend bent in deze video. 
 Het is waar dat de aanwijzers je de mogelijkheid bieden 
 om het misschien behoorlijk te verpesten als je dat bent 
 werken met variabelen en gegevens en ervoor zorgen dat uw programma crasht. 
 Maar ze zijn eigenlijk heel nuttig en ze laten ons een geweldige manier toe 
 om gegevens heen en weer door te geven tussen functies, 
 die we anders niet zouden kunnen doen. 
 >> Dus wat we hier echt willen doen, is trainen 
 om een ​​goede pointerdiscipline te hebben, zodat u pointers effectief kunt gebruiken 
 om uw programma's veel beter te maken. 
 Zoals ik al zei, geven aanwijzers ons een andere manier om gegevens tussen functies door te geven. 
 Als je je nu herinnert van een eerdere video, wanneer 
 we hadden het over variabele reikwijdte, zei ik 

Spanish: 
 >> [REPRODUCCIÓN DE MÚSICA] 
 >> DOUG LLOYD: Punteros, aquí estamos. 
 Probablemente este sea el tema más difícil. 
 de lo que hablamos en CS50. 
 Y si has leído algo sobre punteros 
 antes de que sea un poco intimidante entrar en este video. 
 Es cierto que los punteros te permiten la habilidad 
 quizás arruinar bastante mal cuando estás 
 trabajando con variables y datos, y haciendo que su programa se bloquee. 
 Pero en realidad son realmente útiles y nos permiten una excelente manera 
 para pasar datos de un lado a otro entre funciones, 
 que de otra manera no podemos hacer. 
 >> Y lo que realmente queremos hacer aquí es entrenar 
 que tenga una buena disciplina de puntero, para que pueda usar los punteros de manera efectiva 
 para hacer que sus programas sean mucho mejores. 
 Como dije, los punteros nos dan una forma diferente de pasar datos entre funciones. 
 Ahora, si recuerdas de un video anterior, cuando 
 estábamos hablando de alcance variable, mencioné 

French: 
 >> [JEU DE MUSIQUE] 
 >> DOUG LLOYD: Pointeurs, nous y sommes. 
 Ce sera probablement le sujet le plus difficile 
 dont nous parlons dans CS50. 
 Et si vous avez lu quelque chose sur les pointeurs 
 avant d'être intimidant dans cette vidéo. 
 Il est vrai que les pointeurs vous permettent 
 peut-être bousiller assez mal quand vous êtes 
 travailler avec des variables et des données et provoquer le plantage de votre programme. 
 Mais ils sont en fait vraiment utiles et ils nous permettent un très bon moyen 
 pour passer des données entre les fonctions, 
 que nous ne pouvons pas faire autrement. 
 >> Et donc ce que nous voulons vraiment faire ici, c'est former 
 vous devez avoir une bonne discipline de pointeur, afin que vous puissiez utiliser efficacement les pointeurs 
 pour améliorer vos programmes. 
 Comme je l'ai dit, les pointeurs nous donnent une façon différente de transmettre des données entre les fonctions. 
 Maintenant, si vous vous souvenez d'une vidéo antérieure, quand 
 nous parlions de portée variable, j'ai mentionné 

Japanese: 
 >> [音楽演奏] 
 >> DOUG LLOYD：ポインター、ここにいます。 
これはおそらく最も難しいトピックになるでしょう
 CS50で話します。 
ポインタについて何か読んだことがあるなら
あなたがこのビデオに入るのが少し怖いかもしれない前に。 
ポインタがあなたに能力を与えることは事実です
あなたがいるときにおそらくひどく台無しに
変数とデータを操作し、プログラムをクラッシュさせます。 
しかし、それらは実際に本当に便利で、私たちに本当に素晴らしい方法を許可してくれます
関数間でデータをやり取りするには、 
それ以外の場合は不可能です。 
 >>そして、ここで本当にしたいのは電車です
ポインタを効果的に使用できるように、適切なポインタ規律を持っている必要があります。 
あなたのプログラムをもっと良くするために。 
前に述べたように、ポインターは関数間でデータを渡す別の方法を提供します。 
今、以前のビデオから思い出した場合、 
変数のスコープについて話していました。 

Modern Greek (1453-): 
 >> [ΠΑΙΔΙΚΟ ΠΑΙΧΝΙΔΙ] 
 >> DOUG LLOYD: Δείχνει, εδώ είμαστε. 
 Αυτό πιθανότατα θα είναι το πιο δύσκολο θέμα 
 για τα οποία μιλάμε στο CS50. 
 Και αν έχετε διαβάσει κάτι για τους δείκτες 
 προτού να σκεφτείτε λίγο το βίντεο. 
 Είναι αλήθεια ότι οι δείκτες σας επιτρέπουν τη δυνατότητα 
 ίσως να χτυπάνε πολύ άσχημα όταν είσαι 
 να εργάζεστε με μεταβλητές και δεδομένα και να προκαλείτε διακοπή του προγράμματος σας. 
 Αλλά είναι πράγματι πραγματικά χρήσιμες και μας επιτρέπουν έναν πολύ καλό τρόπο 
 για να μεταφέρετε δεδομένα εμπρός και πίσω μεταξύ λειτουργιών, 
 ότι διαφορετικά δεν μπορούμε να κάνουμε. 
 >> Και αυτό που πραγματικά θέλουμε να κάνουμε εδώ είναι η αμαξοστοιχία 
 μπορείτε να έχετε καλή πειθαρχία δείκτη, έτσι ώστε να μπορείτε να χρησιμοποιήσετε δείκτες αποτελεσματικά 
 για να κάνετε τα προγράμματά σας πολύ καλύτερα. 
 Όπως είπα, οι δείκτες μας δίνουν έναν διαφορετικό τρόπο μετάδοσης δεδομένων μεταξύ λειτουργιών. 
 Τώρα αν θυμάστε από ένα προηγούμενο βίντεο, πότε 
 μιλάμε για μεταβλητό πεδίο εφαρμογής, ανέφερα 

Russian: 
 >> [ВОСПРОИЗВЕДЕНИЕ МУЗЫКИ] 
 >> DOUG LLOYD: указатели, вот и мы. 
 Вероятно, это будет самая сложная тема 
 о котором мы говорим в CS50. 
 И если вы читали что-нибудь о указателях 
 прежде чем вы будете немного пугающим, заходя в это видео. 
 Это правда, что указатели позволяют вам 
 возможно, облажаться, когда ты 
 работа с переменными и данными, вызывающая сбой вашей программы. 
 Но они на самом деле очень полезны, и они позволяют нам действительно отличный способ 
 передавать данные назад и вперед между функциями, 
 что мы в противном случае не можем сделать. 
 >> И вот что мы действительно хотим сделать, это поезд 
 Вы должны иметь хорошую дисциплину указателей, так что вы можете эффективно использовать указатели 
 сделать ваши программы намного лучше. 
 Как я уже говорил, указатели дают нам другой способ передачи данных между функциями. 
 Теперь, если вы помните из более раннего видео, когда 
 мы говорили о переменной области, я упоминал 

German: 
 >> [MUSIK SPIELEN] 
 >> DOUG LLOYD: Zeiger, hier sind wir. 
 Dies wird wahrscheinlich das schwierigste Thema sein 
 über die wir in CS50 sprechen. 
 Und wenn Sie etwas über Zeiger gelesen haben 
 bevor Sie vielleicht ein wenig einschüchternd in dieses Video gehen. 
 Es ist wahr, die Zeiger erlauben Ihnen die Fähigkeit 
 vielleicht ziemlich schlimm vermasseln, wenn du bist 
 Arbeiten mit Variablen und Daten und Absturz Ihres Programms. 
 Aber sie sind wirklich sehr nützlich und ermöglichen uns einen wirklich großartigen Weg 
 Daten zwischen Funktionen hin und her zu übertragen, 
 das können wir sonst nicht. 
 >> Und was wir hier wirklich tun wollen, ist Zug 
 Sie müssen eine gute Zeigerdisziplin haben, damit Sie Zeiger effektiv einsetzen können 
 um Ihre Programme so viel besser zu machen. 
 Wie gesagt, Zeiger geben uns eine andere Möglichkeit, Daten zwischen Funktionen zu übertragen. 
 Wenn Sie sich an ein früheres Video erinnern, wann 
 Wir sprachen über variablen Umfang, erwähnte ich 

Italian: 
 >> [GIOCO DI MUSICA] 
 >> DOUG LLOYD: Puntatori, eccoci qui. 
 Questo sarà probabilmente l'argomento più difficile 
 di cui parliamo in CS50. 
 E se hai letto qualcosa sui puntatori 
 prima che tu possa essere un po 'intimidatorio andando in questo video. 
 È vero che i puntatori ti consentono l'abilità 
 forse rovinare abbastanza male quando lo sei 
 lavorare con variabili e dati e causare l'arresto anomalo del programma. 
 Ma in realtà sono davvero utili e ci consentono un modo davvero eccezionale 
 per passare i dati avanti e indietro tra le funzioni, 
 che altrimenti non saremmo in grado di fare. 
 >> E quindi quello che vogliamo davvero fare qui è il treno 
 avere una buona disciplina dei puntatori, in modo da poter usare i puntatori in modo efficace 
 per rendere i tuoi programmi molto migliori. 
 Come ho detto, i puntatori ci danno un modo diverso di passare i dati tra le funzioni. 
 Ora, se ricordi da un video precedente, quando 
 stavamo parlando di portata variabile, ho detto 

Chinese: 
 >> [音乐播放] 
 >> DOUG LLOYD：指针，到了。 
这可能是最困难的话题
我们在CS50中谈到的
如果您已阅读有关指针的任何内容
然后您可能会有点害怕这个视频。 
的确，指针确实允许您
可能会严重破坏您
使用变量和数据，并导致程序崩溃。 
但是它们实际上是非常有用的，它们使我们有一个非常好的方法
在功能之间来回传递数据， 
否则我们无法做到。 
 >>所以我们这里真正想做的是火车
您要有良好的指针纪律，以便可以有效地使用指针
使您的程序更好。 
正如我所说的，指针为我们提供了一种在函数之间传递数据的不同方法。 
现在，如果您回想起之前的视频， 
我说的是可变范围

English: 
>> [MUSIC PLAYING]
>> DOUG LLOYD: Pointers, here we are.
This is probably going to be the most difficult topic
that we talk about in CS50.
And if you've read anything about pointers
before you might be a little bit intimidating going into this video.
It's true the pointers do allow you the ability
to perhaps screw up pretty badly when you're
working with variables, and data, and causing your program to crash.
But they're actually really useful and they allow us a really great way
to pass data back and forth between functions,
that we're otherwise unable to do.
>> And so what we really want to do here is train
you to have good pointer discipline, so that you can use pointers effectively
to make your programs that much better.
As I said pointers give us a different way to pass data between functions.
Now if you recall from an earlier video, when
we were talking about variable scope, I mentioned

Portuguese: 
 >> [Tocando música] 
 >> DOUG LLOYD: Ponteiros, aqui estamos. 
 Esse provavelmente será o tópico mais difícil 
 sobre o qual falamos no CS50. 
 E se você leu algo sobre ponteiros 
 antes que você possa ser um pouco intimidante ao entrar neste vídeo. 
 É verdade que os ponteiros permitem a capacidade 
 talvez estragar muito quando você está 
 trabalhando com variáveis ​​e dados e causando falha no seu programa. 
 Mas eles são realmente muito úteis e nos permitem uma ótima maneira 
 para passar dados entre funções, 
 que de outra forma não podemos fazer. 
 >> E então o que realmente queremos fazer aqui é treinar 
 você tenha uma boa disciplina de ponteiro, para poder usar os ponteiros efetivamente 
 para tornar seus programas muito melhores. 
 Como eu disse, os ponteiros nos dão uma maneira diferente de transmitir dados entre funções. 
 Agora, se você se lembra de um vídeo anterior, quando 
 estávamos falando sobre escopo variável, mencionei 

Indonesian: 
 >> [MAIN MUSIK] 
 >> DOUG LLOYD: Pointer, ini dia. 
 Ini mungkin akan menjadi topik yang paling sulit 
 yang kita bicarakan di CS50. 
 Dan jika Anda sudah membaca apa pun tentang petunjuk 
 sebelum Anda mungkin sedikit mengintimidasi masuk ke video ini. 
 Memang benar pointer memungkinkan Anda kemampuan 
 mungkin mengacaukan cukup buruk ketika Anda 
 bekerja dengan variabel, dan data, dan menyebabkan program Anda macet. 
 Tapi mereka sebenarnya sangat berguna dan memungkinkan kita cara yang hebat 
 untuk meneruskan data antara fungsi, 
 yang tidak dapat kami lakukan. 
 >> Jadi yang ingin kami lakukan di sini adalah kereta 
 Anda harus memiliki disiplin pointer yang baik, sehingga Anda dapat menggunakan pointer secara efektif 
 untuk membuat program Anda jauh lebih baik. 
 Seperti yang saya katakan, pointer memberi kita cara berbeda untuk melewatkan data antar fungsi. 
 Sekarang jika Anda ingat dari video sebelumnya, kapan 
 kami berbicara tentang ruang lingkup variabel, saya sebutkan 

Turkish: 
 >> [MÜZİK ÇALMA] 
 >> DOUG LLOYD: İşaretçiler, işte buradayız. 
 Bu muhtemelen en zor konu olacak 
 CS50'de bahsettiğimiz 
 Ve işaretçiler hakkında bir şey okuduysanız 
 Bu videoya girerken biraz korkutucu olabilirsiniz. 
 İşaretçilerin sana izin verdiği doğrudur 
 belki de 
 değişkenler ve verilerle çalışma ve programınızın çökmesine neden olma. 
 Ama gerçekten çok kullanışlılar ve bize gerçekten harika bir yol sağlıyorlar 
 verileri fonksiyonlar arasında ileri ve geri aktarmak, 
 aksi takdirde yapamayız. 
 >> Ve burada gerçekten yapmak istediğimiz şey tren 
 işaretçileri etkili bir şekilde kullanabilmeniz için iyi bir işaret disipline sahip olmanız gerekir 
 programlarınızı daha iyi hale getirmek için. 
 Dediğim gibi işaretçiler bize fonksiyonlar arasında veri aktarımı için farklı bir yol sunuyor. 
 Daha önceki bir videodan hatırlarsanız, 
 değişken kapsamdan bahsediyorduk 

English: 
that all the data that we pass between functions in C is passed by value.
And I may not have used that term, what I meant there
was that we are passing copies of data.
When we pass a variable to a function, we're not actually passing the variable
to the function, right?
We're passing a copy of that data to the function.
The function does what it will and it calculates some value,
and maybe we use that value when it gives it back.
>> There was one exception to this rule of passing by value,
and we'll come back to what that is a little later on in this video.
If we use pointers instead of using variables,
or instead of using the variables themselves or copies of the variables,
we can now pass the variables around between functions in a different way.
This means that if we make a change in one function,
that change will actually take effect in a different function.
Again, this is something that we couldn't do previously,
and if you've ever tried to swap the value of two variables in a function,
you've noticed this problem sort of creeping up, right?

Chinese: 
我們在C函數之間傳遞的所有數據都是按值傳遞的。 
我可能沒有用過這個詞
是我們正在傳遞數據副本。 
當我們將變量傳遞給函數時，實際上並沒有傳遞變量
功能，對不對？ 
我們正在將該數據的副本傳遞給函數。 
該函數將執行其操作併計算出一些值， 
也許我們在返回值時就使用該值。 
 >>按值傳遞的規則有一個例外， 
我們將回到本視頻的稍後部分。 
如果我們使用指針而不是變量， 
或者代替使用變量本身或變量副本， 
我們現在可以以不同的方式在函數之間傳遞變量。 
這意味著如果我們更改一個功能， 
該更改實際上將在其他功能中生效。 
再說一次，這是我們以前無法做到的， 
如果您曾經嘗試在函數中交換兩個變量的值， 
您注意到這個問題正在蔓延，對嗎？ 

Chinese: 
我们在C函数之间传递的所有数据都是按值传递的。 
我可能没有用过这个词
是我们正在传递数据副本。 
当我们将变量传递给函数时，实际上并没有传递变量
功能，对不对？ 
我们正在将该数据的副本传递给函数。 
该函数将执行其操作并计算出一些值， 
也许我们在返回值时就使用该值。 
 >>按值传递的规则有一个例外， 
我们将回到本视频的稍后部分。 
如果我们使用指针而不是变量， 
或者代替使用变量本身或变量副本， 
我们现在可以以不同的方式在函数之间传递变量。 
这意味着如果我们更改一个功能， 
该更改实际上将在其他功能中生效。 
再说一次，这是我们以前无法做到的， 
如果您曾经尝试在函数中交换两个变量的值， 
您注意到这个问题正在蔓延，对吗？ 

Hindi: 
 वह सभी डेटा जो हम C में फ़ंक्शन के बीच से गुजरते हैं, मान द्वारा पारित किया जाता है। 
 और हो सकता है कि मैंने उस शब्द का इस्तेमाल न किया हो, मेरा वहां क्या मतलब था 
 यह था कि हम डेटा की प्रतियां पास कर रहे हैं। 
 जब हम किसी चर को किसी फ़ंक्शन में पास करते हैं, तो हम वास्तव में चर को पारित नहीं कर रहे हैं 
 समारोह के लिए, है ना? 
 हम फ़ंक्शन में उस डेटा की एक प्रति दे रहे हैं। 
 फ़ंक्शन यह करता है कि यह क्या करेगा और यह कुछ मूल्य की गणना करता है, 
 और शायद हम उस मूल्य का उपयोग करते हैं जब वह इसे वापस देता है। 
 >> मूल्य से गुजरने के इस नियम का एक अपवाद था, 
 और हम इस वीडियो में थोड़ी देर बाद आएंगे। 
 यदि हम चर का उपयोग करने के बजाय संकेत का उपयोग करते हैं, 
 या स्वयं चर का उपयोग करने या चर की प्रतियों के बजाय, 
 अब हम एक अलग तरीके से कार्यों के बीच चर को पास कर सकते हैं। 
 इसका मतलब है कि अगर हम एक फ़ंक्शन में बदलाव करते हैं, 
 यह परिवर्तन वास्तव में एक अलग फ़ंक्शन में प्रभावी होगा। 
 फिर, यह कुछ ऐसा है जो हम पहले नहीं कर सकते थे, 
 और यदि आपने कभी किसी फ़ंक्शन में दो चर का मान स्वैप करने की कोशिश की है, 
 आपने देखा है कि यह समस्या ठीक है? 

Japanese: 
 Cの関数間で渡されるすべてのデータは、値によって渡されることに注意してください。 
そして、私はその用語を使用しなかったかもしれません、そこで私が意味したこと
データのコピーを渡すことでした。 
変数を関数に渡すとき、実際には変数を渡していません
機能にね？ 
そのデータのコピーを関数に渡します。 
関数はそれが行うことを行い、いくつかの値を計算し、 
おそらく、それを返すときにその値を使用します。 
 >>この値渡しのルールには1つの例外がありました。 
それについては、このビデオで少し後で説明します。 
変数ではなくポインタを使用すると、 
または、変数自体または変数のコピーを使用する代わりに、 
これで、関数間で変数を別の方法で渡すことができます。 
つまり、1つの関数に変更を加えると、 
その変更は、実際には別の関数で有効になります。 
繰り返しますが、これは以前はできなかったことです。 
関数内の2つの変数の値を交換しようとしたことがある場合は、 
あなたはこの問題が一種の忍び寄るのに気づきましたよね？ 

Turkish: 
 C'deki işlevler arasında ilettiğimiz tüm verilerin değere göre aktarılması. 
 Ve o terimi kullanmamış olabilirim, orada ne demek istediğimi 
 verilerin kopyalarını geçiriyor olmamızdı. 
 Bir değişkeni bir işleve geçirdiğimizde, aslında değişkeni geçirmiyoruz 
 fonksiyona değil mi? 
 Bu verilerin bir kopyasını işleve aktarıyoruz. 
 İşlev ne yapacağını yapar ve bir değer hesaplar, 
 ve belki bu değeri geri verirken kullanırız. 
 >> Bu değerden geçme kuralında bir istisna vardı, 
 ve biraz sonra bu videoda bunun ne olduğuna geri döneceğiz. 
 Değişkenler kullanmak yerine işaretçiler kullanırsak, 
 veya değişkenlerin kendisini veya değişkenlerin kopyalarını kullanmak yerine, 
 şimdi değişkenleri fonksiyonlar arasında farklı bir şekilde aktarabiliriz. 
 Bu, bir işlevde değişiklik yaparsak, 
 bu değişiklik aslında farklı bir işlevde etkili olacaktır. 
 Yine, bu daha önce yapamayacağımız bir şey, 
 ve bir işlevdeki iki değişkenin değerini değiştirmeyi denediyseniz, 
 bu sorunu bir çeşit sürünen fark ettiniz, değil mi? 

German: 
 dass alle Daten, die wir zwischen Funktionen in C übergeben, als Wert übergeben werden. 
 Und ich habe diesen Begriff vielleicht nicht verwendet, was ich dort gemeint habe 
 war, dass wir Kopien von Daten übergeben. 
 Wenn wir eine Variable an eine Funktion übergeben, übergeben wir die Variable nicht 
 zur Funktion, richtig? 
 Wir übergeben eine Kopie dieser Daten an die Funktion. 
 Die Funktion macht was sie will und berechnet einen Wert, 
 und vielleicht verwenden wir diesen Wert, wenn er zurückgegeben wird. 
 >> Es gab eine Ausnahme von dieser Regel der Wertübergabe: 
 und wir werden etwas später in diesem Video darauf zurückkommen. 
 Wenn wir Zeiger anstelle von Variablen verwenden, 
 oder anstatt die Variablen selbst oder Kopien der Variablen zu verwenden, 
 Wir können jetzt die Variablen auf unterschiedliche Weise zwischen Funktionen weitergeben. 
 Dies bedeutet, dass, wenn wir eine Funktion ändern, 
 Diese Änderung wird tatsächlich in einer anderen Funktion wirksam. 
 Auch dies ist etwas, was wir vorher nicht konnten, 
 und wenn Sie jemals versucht haben, den Wert von zwei Variablen in einer Funktion zu tauschen, 
 Sie haben bemerkt, dass sich dieses Problem irgendwie eingeschlichen hat, oder? 

Indonesian: 
 bahwa semua data yang kami lewati antara fungsi dalam C dilewatkan oleh nilai. 
 Dan saya mungkin tidak menggunakan istilah itu, apa yang saya maksudkan di sana 
 adalah bahwa kami mengirimkan salinan data. 
 Saat kita meneruskan variabel ke suatu fungsi, kita sebenarnya tidak meneruskan variabel 
 ke fungsi, kan? 
 Kami meneruskan salinan data itu ke fungsi. 
 Fungsi melakukan apa yang diinginkannya dan menghitung beberapa nilai, 
 dan mungkin kita menggunakan nilai itu ketika mengembalikannya. 
 >> Ada satu pengecualian untuk aturan ini lewat nilai, 
 dan kami akan kembali ke apa itu nanti di video ini. 
 Jika kita menggunakan pointer daripada menggunakan variabel, 
 atau alih-alih menggunakan variabel sendiri atau salinan variabel, 
 kita sekarang dapat meneruskan variabel di sekitar antara fungsi dengan cara yang berbeda. 
 Ini berarti bahwa jika kita membuat perubahan dalam satu fungsi, 
 perubahan itu sebenarnya akan berpengaruh pada fungsi yang berbeda. 
 Sekali lagi, ini adalah sesuatu yang tidak bisa kita lakukan sebelumnya, 
 dan jika Anda pernah mencoba menukar nilai dua variabel dalam suatu fungsi, 
 Anda telah melihat masalah semacam ini merayap, kan? 

Portuguese: 
 que todos os dados que passamos entre funções em C são passados ​​por valor. 
 E eu posso não ter usado esse termo, o que eu quis dizer lá 
 foi que estamos passando cópias de dados. 
 Quando passamos uma variável para uma função, na verdade não estamos passando a variável 
 para a função, certo? 
 Estamos passando uma cópia desses dados para a função. 
 A função faz o que quer e calcula algum valor, 
 e talvez possamos usar esse valor quando o devolvermos. 
 >> Havia uma exceção a essa regra de passar por valor, 
 e voltaremos ao que é um pouco mais adiante neste vídeo. 
 Se usarmos ponteiros em vez de usar variáveis, 
 ou em vez de usar as próprias variáveis ​​ou cópias das variáveis, 
 agora podemos passar as variáveis ​​entre as funções de uma maneira diferente. 
 Isso significa que, se fizermos uma alteração em uma função, 
 essa mudança terá efeito em uma função diferente. 
 Novamente, isso é algo que não podíamos fazer anteriormente, 
 e se você já tentou trocar o valor de duas variáveis ​​em uma função, 
 você notou esse problema meio que surgindo, certo? 

Italian: 
 che tutti i dati che passiamo tra le funzioni in C sono passati per valore. 
 E potrei non aver usato quel termine, cosa intendevo lì 
 era che stiamo passando copie di dati. 
 Quando passiamo una variabile a una funzione, in realtà non stiamo passando la variabile 
 alla funzione, giusto? 
 Stiamo trasmettendo una copia di tali dati alla funzione. 
 La funzione fa quello che vuole e calcola un valore, 
 e forse usiamo quel valore quando lo restituisce. 
 >> C'era un'eccezione a questa regola di passaggio per valore, 
 e torneremo a quello che è poco dopo in questo video. 
 Se utilizziamo i puntatori anziché utilizzare le variabili, 
 o invece di utilizzare le variabili stesse o copie delle variabili, 
 ora possiamo passare le variabili tra le funzioni in modo diverso. 
 Ciò significa che se facciamo una modifica in una funzione, 
 tale modifica avrà effettivamente effetto in una funzione diversa. 
 Ancora una volta, questo è qualcosa che non potevamo fare prima, 
 e se hai mai provato a scambiare il valore di due variabili in una funzione, 
 hai notato che questo problema si sta insinuando, giusto? 

Korean: 
 C에서 함수간에 전달하는 모든 데이터는 값으로 전달됩니다. 
 그리고 그 용어를 사용하지 않았을 수도 있습니다. 
 데이터 사본을 전달한다는 것이 었습니다. 
 변수를 함수에 전달할 때 실제로 변수를 전달하지 않습니다 
 기능에 맞습니까? 
 해당 데이터의 복사본을 함수에 전달합니다. 
 이 함수는 기능을 수행하고 일부 값을 계산합니다. 
 그 값을 돌려 줄 때 그 값을 사용할 수도 있습니다. 
 >> 가치관을 통과시키는이 규칙에는 한 가지 예외가있었습니다. 
 우리는이 비디오에서 조금 나중에 다시 돌아올 것입니다. 
 변수 대신 포인터를 사용하면 
 또는 변수 자체 또는 변수 사본을 사용하는 대신 
 이제 함수간에 변수를 다른 방식으로 전달할 수 있습니다. 
 즉, 하나의 기능을 변경하면 
 그 변화는 실제로 다른 기능에 적용됩니다. 
 다시, 이것은 우리가 이전에는 할 수 없었던 일입니다. 
 함수에서 두 변수의 값을 바꾸려고 한 경우 
 이 문제가 발생했음을 알았습니다. 

Spanish: 
 que todos los datos que pasamos entre funciones en C se pasan por valor. 
 Y es posible que no haya usado ese término, lo que quise decir allí 
 fue que estamos pasando copias de datos. 
 Cuando pasamos una variable a una función, en realidad no estamos pasando la variable 
 a la función, ¿verdad? 
 Estamos pasando una copia de esos datos a la función. 
 La función hace lo que quiere y calcula algún valor, 
 y tal vez usamos ese valor cuando lo devuelve. 
 >> Hubo una excepción a esta regla de pasar por valor, 
 y volveremos a lo que es un poco más adelante en este video. 
 Si usamos punteros en lugar de usar variables, 
 o en lugar de usar las propias variables o copias de las variables, 
 ahora podemos pasar las variables entre funciones de una manera diferente. 
 Esto significa que si hacemos un cambio en una función, 
 ese cambio realmente tendrá efecto en una función diferente. 
 De nuevo, esto es algo que no podíamos hacer anteriormente, 
 y si alguna vez has intentado intercambiar el valor de dos variables en una función, 
 te has dado cuenta de que este problema está surgiendo, ¿verdad? 

Arabic: 
 أن جميع البيانات التي نمررها بين الدالات في C يتم تمريرها حسب القيمة. 
 وربما لم أكن قد استخدمت هذا المصطلح ، ما قصدته هناك 
 هو أننا نمرر نسخًا من البيانات. 
 عندما نقوم بتمرير متغير إلى دالة ، فإننا لا نمرر المتغير في الواقع 
 إلى الوظيفة ، أليس كذلك؟ 
 نقوم بتمرير نسخة من هذه البيانات إلى الوظيفة. 
 تقوم الوظيفة بما ستقوم به وتحسب بعض القيمة ، 
 وربما نستخدم هذه القيمة عندما تعيدها. 
 >> كان هناك استثناء واحد لقاعدة التمرير بالقيمة ، 
 وسنعود إلى ما سيحدث لاحقًا في هذا الفيديو. 
 إذا استخدمنا المؤشرات بدلاً من استخدام المتغيرات ، 
 أو بدلاً من استخدام المتغيرات نفسها أو نسخ المتغيرات ، 
 يمكننا الآن تمرير المتغيرات بين الدوال بطريقة مختلفة. 
 هذا يعني أنه إذا قمنا بإجراء تغيير في وظيفة واحدة ، 
 سيصبح هذا التغيير نافذ المفعول في وظيفة مختلفة. 
 مرة أخرى ، هذا شيء لم نتمكن من القيام به سابقًا ، 
 وإذا حاولت في أي وقت تبديل قيمة متغيرين في دالة ، 
 لقد لاحظت أن هذه المشكلة تزحف نوعًا ما ، أليس كذلك؟ 

French: 
 que toutes les données que nous transmettons entre les fonctions en C sont transmises par valeur. 
 Et je n'ai peut-être pas utilisé ce terme, ce que je voulais dire 
 c'est que nous transmettons des copies de données. 
 Lorsque nous transmettons une variable à une fonction, nous ne transmettons pas réellement la variable 
 à la fonction, non? 
 Nous transmettons une copie de ces données à la fonction. 
 La fonction fait ce qu'elle veut et calcule une valeur, 
 et peut-être que nous utilisons cette valeur quand elle la rend. 
 >> Il y avait une exception à cette règle de passage par valeur, 
 et nous reviendrons sur ce que c'est un peu plus tard dans cette vidéo. 
 Si nous utilisons des pointeurs au lieu d'utiliser des variables, 
 ou au lieu d'utiliser les variables elles-mêmes ou des copies des variables, 
 nous pouvons maintenant passer les variables entre les fonctions d'une manière différente. 
 Cela signifie que si nous modifions une fonction, 
 ce changement prendra effectivement effet dans une fonction différente. 
 Encore une fois, c'est quelque chose que nous ne pouvions pas faire auparavant, 
 et si vous avez déjà essayé d'échanger la valeur de deux variables dans une fonction, 
 vous avez remarqué ce type de problème, non? 

Modern Greek (1453-): 
 ότι όλα τα δεδομένα που περάσαμε μεταξύ των λειτουργιών στο C διαβιβάζονται με τιμή. 
 Και ίσως να μην χρησιμοποίησα αυτόν τον όρο, αυτό που εννοούσα εκεί 
 ήταν ότι διαβιβάζουμε αντίγραφα των δεδομένων. 
 Όταν μεταβιβάζουμε μια μεταβλητή σε μια συνάρτηση, δεν μεταβιβάζουμε την μεταβλητή 
 στη λειτουργία, σωστά; 
 Περνάμε ένα αντίγραφο αυτών των δεδομένων στη λειτουργία. 
 Η λειτουργία κάνει αυτό που θα κάνει και υπολογίζει κάποια αξία, 
 και ίσως χρησιμοποιούμε αυτή την αξία όταν την επαναφέρει. 
 >> Υπήρχε μια εξαίρεση από τον κανόνα αυτό της διέλευσης από την αξία, 
 και θα επιστρέψουμε σε αυτό που είναι λίγο αργότερα σε αυτό το βίντεο. 
 Αν χρησιμοποιούμε δείκτες αντί να χρησιμοποιούμε μεταβλητές, 
 ή αντί να χρησιμοποιούν τις ίδιες τις μεταβλητές ή αντίγραφα των μεταβλητών, 
 μπορούμε τώρα να περάσουμε τις μεταβλητές μεταξύ των λειτουργιών με διαφορετικό τρόπο. 
 Αυτό σημαίνει ότι εάν κάνουμε μια αλλαγή σε μία λειτουργία, 
 αυτή η αλλαγή θα έχει ουσιαστικά αποτελέσματα σε μια διαφορετική λειτουργία. 
 Και πάλι, αυτό είναι κάτι που δεν μπορούσαμε να κάνουμε στο παρελθόν, 
 και αν έχετε προσπαθήσει ποτέ να αλλάξετε την τιμή δύο μεταβλητών σε μια λειτουργία, 
 Έχετε παρατηρήσει αυτό το πρόβλημα είδος αναρρίχηση επάνω, έτσι; 

Dutch: 
 dat alle gegevens die we tussen functies in C doorgeven, door waarde worden doorgegeven. 
 En misschien heb ik die term niet gebruikt, wat ik daar bedoelde 
 was dat we kopieën van gegevens doorgeven. 
 Wanneer we een variabele doorgeven aan een functie, geven we de variabele niet echt door 
 aan de functie, toch? 
 We geven een kopie van die gegevens door aan de functie. 
 De functie doet wat het wil en berekent een bepaalde waarde, 
 en misschien gebruiken we die waarde wanneer het deze teruggeeft. 
 >> Er was één uitzondering op deze regel van doorgeven door waarde, 
 en we komen later terug op wat dat is in deze video. 
 Als we pointers gebruiken in plaats van variabelen, 
 of in plaats van de variabelen zelf of kopieën van de variabelen te gebruiken, 
 we kunnen de variabelen tussen functies nu op een andere manier doorgeven. 
 Dit betekent dat als we een wijziging aanbrengen in één functie, 
 die verandering zal daadwerkelijk effect hebben in een andere functie. 
 Nogmaals, dit is iets wat we voorheen niet konden doen, 
 en als je ooit hebt geprobeerd de waarde van twee variabelen in een functie om te wisselen, 
 je hebt gemerkt dat dit probleem een ​​beetje omhoog kruipt, toch? 

Russian: 
 что все данные, которые мы передаем между функциями в C, передаются по значению. 
 И я, возможно, не использовал этот термин, что я имел в виду там 
 было то, что мы передаем копии данных. 
 Когда мы передаем переменную в функцию, мы на самом деле не передаем переменную 
 к функции, верно? 
 Мы передаем копию этих данных в функцию. 
 Функция делает то, что хочет, и вычисляет некоторое значение, 
 и, возможно, мы используем это значение, когда оно возвращает его. 
 >> Было одно исключение из этого правила передачи по значению, 
 и мы вернемся к этому чуть позже в этом видео. 
 Если мы используем указатели вместо использования переменных, 
 или вместо того, чтобы использовать сами переменные или копии переменных, 
 Теперь мы можем передавать переменные между функциями по-другому. 
 Это означает, что если мы сделаем изменение в одной функции, 
 это изменение действительно вступит в силу в другой функции. 
 Опять же, это то, что мы не могли сделать раньше, 
 и если вы когда-нибудь пытались поменять значение двух переменных в функции, 
 Вы заметили, что эта проблема как бы подкрадывается, верно? 

Korean: 
 >> X와 Y를 바꾸고 싶다면 swap이라는 함수에 전달하면 
 함수 스왑 내부에서 변수는 값을 교환합니다. 
 하나는 둘이되고 둘은 하나가되지만 실제로는 그렇지 않습니다 
 발신자에서 원래 기능의 내용을 변경하십시오. 
 우리는 할 수 없기 때문에 사본으로 만 작업하고 있습니다. 
 그러나 포인터를 사용하면 실제로 X와 Y를 함수에 전달할 수 있습니다. 
 그 기능은 그들과 함께 뭔가를 할 수 있습니다. 
 이러한 변수 값은 실제로 변경 될 수 있습니다. 
 이는 데이터 작업 능력에있어 상당한 변화입니다. 
 >> 우리가 포인터로 뛰어 들기 전에 가치가 있다고 생각합니다. 
 기본으로 돌아가려면 몇 분이 걸립니다. 
 컴퓨터 메모리 작동 방식을 살펴보십시오 
 이 두 과목은 실제로 서로 관련이 있기 때문입니다. 
 아시다시피 컴퓨터 시스템에서 
 하드 드라이브 또는 솔리드 스테이트 드라이브가 있거나 
 일종의 파일 저장 위치. 
 일반적으로 250 기가 바이트의 어딘가에 있습니다. 
 아마 몇 테라 바이트 정도입니다. 

Turkish: 
 >> X ve Y'yi değiştirmek istiyorsak ve onları takas adı verilen bir işleve geçirirsek, 
 değiş tokuş fonksiyonunun içinde değiş tokuş değerleri yapar. 
 Biri iki olur, ikisi bir olur, ama aslında 
 orijinal işlevdeki, arayandaki herhangi bir şeyi değiştirir. 
 Çünkü yapamayız, sadece kopyaları ile çalışıyoruz. 
 Yine de işaretçilerle, aslında X ve Y'yi bir işleve geçirebiliriz. 
 Bu işlev onlarla bir şeyler yapabilir. 
 Ve bu değişken değerleri gerçekten değişebilir. 
 Yani bu verilerle çalışma yeteneğimizde bir değişiklik. 
 >> İşaretçilere dalmadan önce, bence buna değer 
 burada temel bilgilere geri dönmek için birkaç dakikanızı ayırın. 
 Bilgisayar belleğinin nasıl çalıştığına bir göz atın 
 çünkü bu iki konu aslında birbiriyle oldukça ilişkili olacak. 
 Muhtemelen bildiğiniz gibi, bilgisayar sisteminizde 
 sabit sürücünüz veya katı hal sürücünüz olabilir, 
 bir tür dosya depolama yeri. 
 Genellikle 250 gigabayt civarında bir yerdedir 
 belki birkaç terabayta. 

Arabic: 
 >> إذا أردنا التبديل بين X و Y ، وننقلهما إلى دالة تسمى مبادلة ، 
 داخل الدالة بتبديل المتغيرات قيم التبادل. 
 واحد يصبح اثنان ، اثنان يصبحان واحد ، لكننا في الحقيقة لا 
 تغيير أي شيء في الوظيفة الأصلية ، في المتصل. 
 لأننا لا نستطيع ، نحن نعمل فقط مع نسخ منها. 
 مع المؤشرات ، يمكننا تمرير X و Y إلى دالة. 
 يمكن لهذه الوظيفة أن تفعل شيئا معهم. 
 ويمكن أن تتغير قيم المتغيرات بالفعل. 
 إذن هذا تغيير كبير في قدرتنا على العمل مع البيانات. 
 >> قبل أن نتعمق في المؤشرات ، أعتقد أن الأمر يستحق 
 يستغرق بضع دقائق للعودة إلى الأساسيات هنا. 
 وإلقاء نظرة على كيفية عمل ذاكرة الكمبيوتر 
 لأن هذين الموضوعين سيكونان مترابطين جدًا. 
 كما تعلم على الأرجح ، على نظام الكمبيوتر الخاص بك 
 لديك محرك أقراص ثابت أو ربما محرك أقراص ذو حالة صلبة ، 
 نوع من موقع تخزين الملفات. 
 عادة ما يكون في مكان ما في حي 250 غيغابايت 
 ربما بضعة تيرابايت الآن. 

Modern Greek (1453-): 
 >> Αν θέλουμε να ανταλλάξουμε X και Y και τους μεταφέρουμε σε μια λειτουργία που ονομάζεται swap, 
 Στο εσωτερικό της συνάρτησης ανταλλαγής οι μεταβλητές κάνουν τις τιμές ανταλλαγής. 
 Κάποιος γίνεται δύο, δύο γίνεται ένας, αλλά δεν έχουμε στην πραγματικότητα 
 να αλλάξετε οτιδήποτε στην αρχική λειτουργία, στον καλούντα. 
 Επειδή δεν μπορούμε, δουλεύουμε μόνο με αντίγραφα αυτών. 
 Με δείκτες όμως, μπορούμε να περάσουμε πραγματικά X και Y σε μια λειτουργία. 
 Αυτή η λειτουργία μπορεί να κάνει κάτι μαζί τους. 
 Και αυτές οι τιμές μεταβλητών μπορούν πραγματικά να αλλάξουν. 
 Αυτή είναι λοιπόν μια μεγάλη αλλαγή στην ικανότητά μας να δουλεύουμε με δεδομένα. 
 >> Πριν βυθίσουμε τους δείκτες, νομίζω ότι αξίζει 
 κάνοντας λίγα λεπτά για να επιστρέψετε στα βασικά εδώ. 
 Και ρίξτε μια ματιά στο πώς λειτουργεί η μνήμη του υπολογιστή 
 γιατί αυτά τα δύο θέματα θα είναι πραγματικά αρκετά αλληλένδετα. 
 Όπως ίσως γνωρίζετε, στο σύστημα του υπολογιστή σας 
 έχετε έναν σκληρό δίσκο ή ίσως μια μονάδα SSD, 
 κάποιο είδος θέσης αποθήκευσης αρχείων. 
 Είναι συνήθως κάπου στην περιοχή των 250 gigabytes 
 ίσως μερικά terabytes τώρα. 

Italian: 
 >> Se vogliamo scambiare X e Y e li passiamo a una funzione chiamata swap, 
 all'interno della funzione di scambio le variabili scambiano valori. 
 Uno diventa due, due diventano uno, ma in realtà non lo facciamo 
 cambia qualcosa nella funzione originale, nel chiamante. 
 Perché non possiamo, stiamo solo lavorando con loro copie. 
 Con i puntatori però, possiamo effettivamente passare X e Y a una funzione. 
 Quella funzione può fare qualcosa con loro. 
 E quei valori delle variabili possono effettivamente cambiare. 
 Quindi questo è abbastanza un cambiamento nella nostra capacità di lavorare con i dati. 
 >> Prima di immergerci nei puntatori, penso che valga la pena 
 prendendo qualche minuto per tornare alle basi qui. 
 E dai un'occhiata a come funziona la memoria del computer 
 perché queste due materie saranno in realtà piuttosto correlate. 
 Come probabilmente saprai, sul tuo computer 
 hai un disco rigido o forse un disco a stato solido, 
 una sorta di posizione di archiviazione dei file. 
 Di solito è da qualche parte nel quartiere di 250 gigabyte 
 forse un paio di terabyte ora. 

Dutch: 
 >> Als we X en Y willen verwisselen, en we geven ze door aan een functie genaamd swap, 
 binnen de functie swap wisselen de variabelen waarden uit. 
 Eén wordt twee, twee wordt één, maar eigenlijk niet 
 verander alles in de oorspronkelijke functie, in de beller. 
 Omdat we dat niet kunnen, werken we alleen met kopieën ervan. 
 Met verwijzingen kunnen we X en Y echter daadwerkelijk doorgeven aan een functie. 
 Die functie kan er iets mee doen. 
 En die variabelenwaarden kunnen zelfs veranderen. 
 Dat is dus een behoorlijke verandering in ons vermogen om met data te werken. 
 >> Voordat we dieper ingaan, denk ik dat het de moeite waard is 
 hier een paar minuten over doen om terug te gaan naar de basis. 
 En kijk hoe het computergeheugen werkt 
 omdat deze twee onderwerpen eigenlijk behoorlijk met elkaar samenhangen. 
 Zoals u waarschijnlijk weet, op uw computersysteem 
 je hebt een harde schijf of misschien een SSD-schijf, 
 een soort opslaglocatie voor bestanden. 
 Het is meestal ergens in de buurt van 250 gigabytes 
 tot misschien een paar terabytes nu. 

Hindi: 
 >> यदि हम X और Y को स्वैप करना चाहते हैं, और हम उन्हें स्वैप नामक एक समारोह में पास करते हैं, 
 इस फंक्शन के अंदर वैरिएबल एक्सचेंज वैल्यू को स्वैप करते हैं। 
 एक दो हो जाते हैं, दो एक हो जाते हैं, लेकिन हम वास्तव में नहीं हैं 
 कॉल करने वाले में मूल फ़ंक्शन में कुछ भी बदलें। 
 क्योंकि हम नहीं कर सकते, हम केवल उनकी प्रतियों के साथ काम कर रहे हैं। 
 संकेत के साथ, हम वास्तव में एक समारोह में X और Y पास कर सकते हैं। 
 वह फंक्शन उनके साथ कुछ कर सकता है। 
 और वे चर मान वास्तव में बदल सकते हैं। 
 इसलिए डेटा के साथ काम करने की हमारी क्षमता में यह काफी बदलाव है। 
 >> इससे पहले कि हम संकेत में गोता लगाते हैं, मुझे लगता है कि यह मूल्य है 
 यहां मूल बातें पर वापस जाने में कुछ मिनट लगते हैं। 
 और कंप्यूटर मेमोरी कैसे काम करती है, इस पर एक नज़र डालें 
 क्योंकि ये दोनों विषय वास्तव में बहुत परस्पर जुड़े हुए हैं। 
 जैसा कि आप शायद जानते हैं, आपके कंप्यूटर सिस्टम पर 
 आपके पास एक हार्ड ड्राइव या शायद एक ठोस राज्य ड्राइव है, 
 किसी प्रकार का फ़ाइल संग्रहण स्थान। 
 यह आमतौर पर 250 गीगाबाइट के पड़ोस में है 
 शायद टेराबाइट्स के एक जोड़े को अब। 

English: 
>> If we want to swap X and Y, and we pass them to a function called swap,
inside of the function swap the variables do exchange values.
One becomes two, two becomes one, but we don't actually
change anything in the original function, in the caller.
Because we can't, we're only working with copies of them.
With pointers though, we can actually pass X and Y to a function.
That function can do something with them.
And those variables values can actually change.
So that's quite a change in our ability to work with data.
>> Before we dive into pointers, I think it's worth
taking a few minutes to go back to basics here.
And have a look at how computer memory works
because these two subjects are going to actually be pretty interrelated.
As you probably know, on your computer system
you have a hard drive or perhaps a solid state drive,
some sort of file storage location.
It's usually somewhere in the neighborhood of 250 gigabytes
to maybe a couple of terabytes now.

Spanish: 
 >> Si queremos intercambiar X e Y, y los pasamos a una función llamada intercambiar, 
 dentro del intercambio de funciones, las variables intercambian valores. 
 Uno se convierte en dos, dos se convierte en uno, pero en realidad no 
 cambiar cualquier cosa en la función original, en la persona que llama. 
 Como no podemos, solo estamos trabajando con copias de ellos. 
 Sin embargo, con los punteros, podemos pasar X e Y a una función. 
 Esa función puede hacer algo con ellos. 
 Y esos valores de variables realmente pueden cambiar. 
 Entonces, eso es un gran cambio en nuestra capacidad para trabajar con datos. 
 >> Antes de sumergirnos en los punteros, creo que vale la pena 
 Tomando unos minutos para volver a lo básico aquí. 
 Y mira cómo funciona la memoria de la computadora 
 porque estos dos temas van a estar realmente interrelacionados 
 Como probablemente sepa, en su sistema informático 
 tiene un disco duro o quizás un disco de estado sólido, 
 algún tipo de ubicación de almacenamiento de archivos. 
 Por lo general, está en algún lugar del vecindario de 250 gigabytes. 
 tal vez un par de terabytes ahora. 

German: 
 >> Wenn wir X und Y tauschen möchten und sie an eine Funktion namens Swap übergeben, 
 Innerhalb des Funktionstauschs tauschen die Variablen Werte aus. 
 Eins wird zwei, zwei wird eins, aber das tun wir eigentlich nicht 
 Ändern Sie alles in der ursprünglichen Funktion im Aufrufer. 
 Weil wir nicht können, arbeiten wir nur mit Kopien davon. 
 Mit Zeigern können wir jedoch X und Y an eine Funktion übergeben. 
 Diese Funktion kann etwas mit ihnen anfangen. 
 Und diese Variablenwerte können sich tatsächlich ändern. 
 Das ist eine ziemliche Veränderung in unserer Fähigkeit, mit Daten zu arbeiten. 
 >> Bevor wir uns mit Zeigern befassen, denke ich, dass es sich lohnt 
 Nehmen Sie sich ein paar Minuten Zeit, um hier zu den Grundlagen zurückzukehren. 
 Und schauen Sie sich an, wie der Computerspeicher funktioniert 
 weil diese beiden Themen tatsächlich ziemlich miteinander zusammenhängen werden. 
 Wie Sie wahrscheinlich wissen, auf Ihrem Computersystem 
 Sie haben eine Festplatte oder vielleicht eine Solid-State-Festplatte, 
 eine Art Dateispeicherort. 
 Es ist normalerweise irgendwo in der Nähe von 250 Gigabyte 
 auf vielleicht ein paar Terabyte jetzt. 

Russian: 
 >> Если мы хотим поменять местами X и Y, и мы передаем их функции под названием swap, 
 внутри функции swap переменные обмениваются значениями. 
 Один становится двумя, два становится одним, но мы на самом деле не 
 изменить что-либо в оригинальной функции, в вызывающей. 
 Потому что мы не можем, мы работаем только с их копиями. 
 С помощью указателей мы можем фактически передать X и Y в функцию. 
 Эта функция может с ними что-то сделать. 
 И эти значения переменных могут действительно измениться. 
 Так что это совсем другое изменение в нашей способности работать с данными. 
 >> Прежде чем мы углубимся в указатели, я думаю, что это стоит 
 займет несколько минут, чтобы вернуться к основам здесь. 
 И посмотрите, как работает память компьютера 
 потому что эти два предмета будут на самом деле довольно взаимосвязаны. 
 Как вы, наверное, знаете, в вашей компьютерной системе 
 у вас есть жесткий диск или, возможно, твердотельный накопитель, 
 какое-то место хранения файлов. 
 Обычно это где-то в районе 250 гигабайт 
 до пары терабайт сейчас. 

Portuguese: 
 >> Se queremos trocar X e Y, e passamos para uma função chamada swap, 
 dentro da função swap as variáveis ​​trocam valores. 
 Um se torna dois, dois se torna um, mas na verdade não 
 altere qualquer coisa na função original, no chamador. 
 Como não podemos, estamos apenas trabalhando com cópias deles. 
 Com ponteiros, porém, podemos realmente passar X e Y para uma função. 
 Essa função pode fazer algo com eles. 
 E esses valores de variáveis ​​podem realmente mudar. 
 Portanto, é uma mudança bastante na nossa capacidade de trabalhar com dados. 
 >> Antes de mergulharmos nos ponteiros, acho que vale a pena 
 levando alguns minutos para voltar ao básico aqui. 
 E veja como a memória do computador funciona 
 porque esses dois assuntos serão realmente inter-relacionados. 
 Como você provavelmente sabe, no seu sistema de computador 
 você tem um disco rígido ou talvez uma unidade de estado sólido, 
 algum tipo de local de armazenamento de arquivos. 
 Geralmente está em algum lugar na faixa de 250 gigabytes 
 para talvez alguns terabytes agora. 

Chinese: 
 >>如果我们要交换X和Y，并将它们传递给一个名为swap的函数， 
在函数swap内部，变量会交换值。 
一变成二，二变成一，但我们实际上并没有
在调用者中更改原始函数中的任何内容。 
因为我们做不到，所以我们只使用它们的副本。 
尽管有了指针，我们实际上可以将X和Y传递给函数。 
该功能可以对他们有所帮助。 
这些变量值实际上可以更改。 
因此，这是我们处理数据能力的巨大变化。 
 >>在我们深入探讨指针之前，我认为值得
花几分钟回到这里的基础知识。 
并看看计算机内存的工作方式
因为这两个主题实际上将相互关联。 
如您所知，在您的计算机系统上
您有硬盘驱动器或固态驱动器， 
某种文件存储位置。 
通常在250 GB附近
现在可能达到几TB。 

Indonesian: 
 >> Jika kita ingin menukar X dan Y, dan kita meneruskannya ke fungsi yang disebut swap, 
 di dalam fungsi swap variabel melakukan pertukaran nilai. 
 Satu menjadi dua, dua menjadi satu, tetapi kita sebenarnya tidak 
 mengubah apa pun dalam fungsi asli, di pemanggil. 
 Karena kami tidak bisa, kami hanya bekerja dengan salinannya. 
 Dengan pointer, kita sebenarnya bisa melewatkan X dan Y ke suatu fungsi. 
 Fungsi itu dapat melakukan sesuatu dengan mereka. 
 Dan nilai-nilai variabel tersebut benar-benar dapat berubah. 
 Jadi itu cukup perubahan dalam kemampuan kita untuk bekerja dengan data. 
 >> Sebelum kita masuk ke pointer, saya pikir itu layak 
 butuh beberapa menit untuk kembali ke dasar-dasar di sini. 
 Dan lihat bagaimana memori komputer bekerja 
 karena dua mata pelajaran ini akan benar-benar saling terkait. 
 Seperti yang mungkin Anda ketahui, di sistem komputer Anda 
 Anda memiliki hard drive atau solid state drive, 
 semacam lokasi penyimpanan file. 
 Biasanya di suatu tempat di lingkungan 250 gigabytes 
 untuk mungkin beberapa terabyte sekarang. 

French: 
 >> Si nous voulons échanger X et Y, et nous les passons à une fonction appelée swap, 
 à l'intérieur de la fonction swap, les variables échangent des valeurs. 
 Un devient deux, deux devient un, mais nous ne le faisons pas réellement 
 changer quoi que ce soit dans la fonction d'origine, dans l'appelant. 
 Parce que nous ne pouvons pas, nous ne travaillons qu'avec des copies. 
 Cependant, avec les pointeurs, nous pouvons réellement passer X et Y à une fonction. 
 Cette fonction peut faire quelque chose avec eux. 
 Et ces valeurs de variables peuvent réellement changer. 
 C'est donc tout un changement dans notre capacité à travailler avec les données. 
 >> Avant de plonger dans les pointeurs, je pense que ça vaut le coup 
 prendre quelques minutes pour revenir à l'essentiel ici. 
 Et regardez comment fonctionne la mémoire de l'ordinateur 
 parce que ces deux sujets vont en fait être assez interdépendants. 
 Comme vous le savez probablement, sur votre système informatique 
 vous avez un disque dur ou peut-être un disque SSD, 
 une sorte d'emplacement de stockage de fichiers. 
 C'est généralement quelque part dans le quartier de 250 gigaoctets 
 à peut-être quelques téraoctets maintenant. 

Chinese: 
 >>如果我們要交換X和Y，並將它們傳遞給一個名為swap的函數， 
在函數swap內部，變量會交換值。 
一變成二，二變成一，但我們實際上並沒有
在調用者中更改原始函數中的任何內容。 
因為我們做不到，所以我們只使用它們的副本。 
儘管有了指針，我們實際上可以將X和Y傳遞給函數。 
該功能可以對他們有所幫助。 
這些變量值實際上可以更改。 
因此，這是我們處理數據能力的巨大變化。 
 >>在我們深入探討指針之前，我認為值得
花幾分鐘回到這裡的基礎知識。 
並看看計算機內存的工作方式
因為這兩個主題實際上將相互關聯。 
如您所知，在您的計算機系統上
您有硬盤驅動器或固態驅動器， 
某種文件存儲位置。 
通常在250 GB附近
現在可能達到幾TB。 

Japanese: 
 >> XとYを入れ替えたい場合、それらをswapという関数に渡します。 
関数swap内では、変数は値を交換します。 
 1つは2つになり、2つは1つになりますが、実際には
呼び出し元で、元の関数のすべてを変更します。 
できないので、私たちはそれらのコピーでのみ作業しています。 
ただし、ポインタを使用すると、XとYを実際に関数に渡すことができます。 
その関数はそれらで何かをすることができます。 
そして、それらの変数の値は実際に変わる可能性があります。 
つまり、データを操作する能力が大きく変わります。 
 >>ポインタに飛び込む前に、それは価値があると思います
ここで基本に戻るには数分かかります。 
そして、コンピュータのメモリがどのように機能するかを見てください
これらの2つの主題は実際にはかなり相互に関連しているためです。 
ご存知かもしれませんが、コンピューターシステム
あなたはハードドライブまたはおそらくソリッドステートドライブを持っています、 
ある種のファイル保管場所。 
通常は250ギガバイトの近くにあります
おそらく数テラバイトになりました。 

Chinese: 
这是您所有文件最终存在的地方， 
即使关闭计算机，也可以将其重新打开
重新启动系统后，您会发现文件又在那里。 
但是磁盘驱动器，例如硬盘驱动器，HDD或固态驱动器，SSD， 
只是存储空间。 
 >>我们实际上无法对硬盘中的数据进行任何处理， 
或固态驱动器中。 
为了实际更改数据或四处移动， 
我们必须将其移至随机存取存储器RAM中。 
现在，RAM减少了计算机中的内存。 
您可能在512兆字节附近
如果您使用的是较旧的计算机，则可能是2、4、8、16 
可能还要多一点GB的RAM。 
因此，它要小得多，但这是所有易失性数据都存在的地方。 
那是我们可以改变事情的地方。 
但是，当我们关闭计算机时，RAM中的所有数据都会被破坏。 
 >>因此，这就是为什么我们需要硬盘来永久固定它， 
这样它存在-如果我们每次

Italian: 
 Ed è lì che vivono tutti i tuoi file, 
 anche quando il computer è spento, è possibile riaccenderlo 
 e scoprirai che i tuoi file sono di nuovo lì quando riavvii il sistema. 
 Ma le unità disco, come un disco rigido, un HDD o un'unità a stato solido, un SSD, 
 sono solo spazio di archiviazione. 
 >> In realtà non possiamo fare nulla con i dati presenti sul disco rigido, 
 o in un'unità a stato solido. 
 Per modificare effettivamente i dati o spostarli, 
 dobbiamo spostarlo su RAM, memoria ad accesso casuale. 
 Ora RAM, ne hai molto meno nel tuo computer. 
 Potresti avere da qualche parte nel quartiere di 512 megabyte 
 se hai un computer più vecchio, forse due, quattro, otto, 16, 
 forse anche un po 'di più, gigabyte di RAM. 
 Quindi è molto più piccolo, ma è lì che esistono tutti i dati volatili. 
 Ecco dove possiamo cambiare le cose. 
 Ma quando spegniamo il nostro computer, tutti i dati nella RAM vengono distrutti. 
 >> Ecco perché è necessario disporre di un disco rigido per la posizione più permanente di esso, 
 in modo che esista, sarebbe davvero brutto se ogni volta noi 

Japanese: 
そして、ここに最終的にすべてのファイルが置かれます。 
コンピュータの電源が切れている場合でも、電源を入れることができます
システムを再起動すると、ファイルが再び表示されます。 
しかし、ハードディスクドライブ、HDD、またはソリッドステートドライブ、SSDなどのディスクドライブ、 
ただの収納スペースです。 
 >>ハードディスクにあるデータを実際に処理することはできません。 
またはソリッドステートドライブ。 
実際にデータを変更したり移動したりするには、 
 RAM、ランダムアクセスメモリに移動する必要があります。 
さて、RAMを使用すると、コンピューターの容量が大幅に少なくなります。 
 512メガバイトのどこかにあるかもしれません
古いコンピュータを使用している場合は、おそらく2、4、8、16 
おそらくさらにギガバイトのRAM。 
したがって、それははるかに小さくなりますが、そこにすべての揮発性データが存在します。 
それは私たちが物事を変えることができる場所です。 
しかし、コンピュータの電源を切ると、RAM内のすべてのデータが破壊されます。 
 >>だからこそ、より永続的な場所にハードディスクを用意する必要があります。 
それが存在するように-私たちが毎回

Hindi: 
 और यह वह जगह है जहाँ आपकी सभी फाइलें अंततः रहती हैं, 
 यहां तक ​​कि जब आपका कंप्यूटर बंद हो जाता है, तो आप इसे वापस चालू कर सकते हैं 
 और आप पाएंगे कि जब आप अपने सिस्टम को रिबूट करेंगे तो आपकी फाइलें फिर से वहीं होंगी। 
 लेकिन हार्ड ड्राइव, एक HDD या एक ठोस राज्य ड्राइव, एक SSD, जैसे डिस्क ड्राइव, 
 बस भंडारण स्थान हैं। 
 >> हम वास्तव में हार्ड डिस्क में मौजूद डेटा के साथ कुछ नहीं कर सकते, 
 या एक ठोस राज्य ड्राइव में। 
 वास्तव में डेटा को बदलने या उसे इधर-उधर करने के लिए, 
 हमें इसे रैम, रैंडम एक्सेस मेमोरी में स्थानांतरित करना होगा। 
 अब RAM, आपके कंप्यूटर में बहुत कम है। 
 आपके पास 512 मेगाबाइट के पड़ोस में कहीं हो सकता है 
 यदि आपके पास एक पुराना कंप्यूटर है, तो शायद दो, चार, आठ, 16, 
 संभवतः थोड़ा और भी, गीगाबाइट रैम। 
 तो यह बहुत छोटा है, लेकिन यह वह जगह है जहाँ सभी अस्थिर डेटा मौजूद हैं। 
 यहीं से हम चीजों को बदल सकते हैं। 
 लेकिन जब हम अपने कंप्यूटर को बंद करते हैं, तो रैम का सारा डेटा नष्ट हो जाता है। 
 >> इसीलिए हमें इसके अधिक स्थाई स्थान के लिए हार्ड डिस्क की आवश्यकता है, 
 ताकि यह मौजूद हो - अगर हम हर बार यह वास्तव में बुरा होगा 

German: 
 Und hier leben letztendlich alle Ihre Dateien. 
 Selbst wenn Ihr Computer ausgeschaltet ist, können Sie ihn wieder einschalten 
 und Sie werden feststellen, dass Ihre Dateien wieder vorhanden sind, wenn Sie Ihr System neu starten. 
 Aber Festplatten, wie ein Festplattenlaufwerk, eine Festplatte oder ein Solid-State-Laufwerk, eine SSD, 
 sind nur Speicherplatz. 
 >> Mit den Daten auf der Festplatte können wir eigentlich nichts anfangen. 
 oder in einem Solid-State-Laufwerk. 
 Um Daten tatsächlich zu ändern oder zu verschieben, 
 wir müssen es in RAM, Direktzugriffsspeicher verschieben. 
 Jetzt haben Sie viel weniger RAM in Ihrem Computer. 
 Möglicherweise haben Sie irgendwo in der Nähe von 512 Megabyte 
 Wenn Sie einen älteren Computer haben, vielleicht zwei, vier, acht, 16, 
 möglicherweise sogar ein bisschen mehr, Gigabyte RAM. 
 Das ist also viel kleiner, aber dort sind alle flüchtigen Daten vorhanden. 
 Hier können wir Dinge ändern. 
 Wenn wir jedoch unseren Computer ausschalten, werden alle Daten im RAM zerstört. 
 >> Deshalb brauchen wir eine Festplatte, um sie dauerhafter zu speichern. 
 so dass es existiert - es wäre wirklich schlimm, wenn wir jedes Mal 

Korean: 
 모든 파일이 궁극적으로 존재하는 곳입니다. 
 컴퓨터가 꺼져 있어도 다시 켤 수 있습니다 
 시스템을 재부팅 할 때 파일이 다시 있다는 것을 알게 될 것입니다. 
 그러나 하드 디스크 드라이브, HDD 또는 SSD (Solid State Drive)와 같은 디스크 드라이브는 
 저장 공간입니다. 
 >> 실제로 하드 디스크에있는 데이터로는 아무것도 할 수 없습니다. 
 또는 솔리드 스테이트 드라이브. 
 실제로 데이터를 변경하거나 이동하려면 
 RAM, 랜덤 액세스 메모리로 옮겨야합니다. 
 이제 RAM, 컴퓨터의 용량이 훨씬 적습니다. 
 512MB 근처에있을 수 있습니다 
 오래된 컴퓨터라면 아마 2, 4, 8, 16, 
 아마도 훨씬 더 많은 기가 바이트의 RAM. 
 따라서 훨씬 작지만 모든 휘발성 데이터가 존재합니다. 
 그것이 우리가 변화시킬 수있는 곳입니다. 
 그러나 컴퓨터를 끄면 RAM의 모든 데이터가 손상됩니다. 
 >> 그래서 더 영구적 인 위치에 하드 디스크가 있어야합니다. 
 우리가 할 때마다 정말 나빠질 것입니다. 

Russian: 
 И это где все ваши файлы в конечном итоге живут, 
 даже когда ваш компьютер выключен, вы можете включить его снова 
 и вы обнаружите, что ваши файлы снова появятся при перезагрузке системы. 
 Но дисководы, такие как жесткий диск, жесткий диск или твердотельный накопитель, SSD, 
 просто место для хранения. 
 >> Мы не можем ничего сделать с данными, которые находятся на жестком диске, 
 или в твердотельном диске. 
 Для того, чтобы реально изменить данные или переместить их, 
 мы должны переместить его в оперативную память, оперативную память. 
 Теперь оперативной памяти у вас гораздо меньше на вашем компьютере. 
 Вы можете иметь где-то в районе 512 мегабайт 
 если у вас есть старый компьютер, может быть, два, четыре, восемь, 16, 
 возможно, даже немного больше, гигабайт оперативной памяти. 
 Так что это намного меньше, но там есть все изменчивые данные. 
 Вот где мы можем что-то изменить. 
 Но когда мы выключаем наш компьютер, все данные в оперативной памяти уничтожаются. 
 >> Так вот почему нам нужен жесткий диск для более постоянного его размещения, 
 так что это существует - было бы очень плохо, если бы каждый раз, когда мы 

Turkish: 
 Ve sonuçta tüm dosyalarınız burada yaşıyor, 
 bilgisayarınız kapalıyken bile tekrar açabilirsiniz 
 ve sisteminizi yeniden başlattığınızda dosyalarınızın tekrar orada olduğunu göreceksiniz. 
 Ancak sabit disk sürücüsü, HDD veya yarıiletken sürücü, SSD gibi disk sürücüleri, 
 sadece depolama alanı. 
 >> Sabit diskteki verilerle hiçbir şey yapamayız, 
 veya yarıiletken sürücüde. 
 Verileri gerçekten değiştirmek veya taşımak için, 
 RAM'e, rasgele erişim belleğine taşımalıyız. 
 Şimdi RAM, bilgisayarınızda çok daha az var. 
 512 megabayt civarında bir yere sahip olabilirsiniz 
 eski bir bilgisayarınız varsa, belki iki, dört, sekiz, 16, 
 muhtemelen biraz daha fazla, gigabayt RAM. 
 Yani bu çok daha küçük, ama tüm değişken verilerin olduğu yer burası. 
 İşte bu noktada bazı şeyleri değiştirebiliriz. 
 Ancak bilgisayarımızı kapattığımızda, RAM'deki tüm veriler yok edilir. 
 >> Bu yüzden daha kalıcı bir yer olması için sabit diske ihtiyacımız var, 
 öyle ki, her seferinde 

French: 
 Et c'est là que tous vos fichiers vivent, 
 même lorsque votre ordinateur est éteint, vous pouvez le rallumer 
 et vous constaterez que vos fichiers sont à nouveau présents lorsque vous redémarrez votre système. 
 Mais les disques durs, comme un disque dur, un disque dur ou un disque SSD, un SSD, 
 ne sont que des espaces de stockage. 
 >> Nous ne pouvons rien faire avec les données qui se trouvent sur le disque dur, 
 ou dans un disque SSD. 
 Pour modifier ou déplacer des données, 
 nous devons le déplacer vers la RAM, la mémoire à accès aléatoire. 
 Maintenant, la RAM, vous en avez beaucoup moins dans votre ordinateur. 
 Vous pouvez avoir quelque part dans le quartier de 512 mégaoctets 
 si vous avez un ordinateur plus ancien, peut-être deux, quatre, huit, 16, 
 peut-être même un peu plus, des gigaoctets de RAM. 
 C'est donc beaucoup plus petit, mais c'est là que toutes les données volatiles existent. 
 C'est là que nous pouvons changer les choses. 
 Mais lorsque nous éteignons notre ordinateur, toutes les données de la RAM sont détruites. 
 >> C'est pourquoi nous avons besoin d'un disque dur pour un emplacement plus permanent, 
 de sorte qu'il existe - ce serait vraiment mauvais si chaque fois que nous 

Spanish: 
 Y es donde finalmente viven todos sus archivos, 
 incluso cuando su computadora está apagada, puede volver a encenderla 
 y encontrará que sus archivos están allí nuevamente cuando reinicie su sistema. 
 Pero las unidades de disco, como una unidad de disco duro, una HDD o una unidad de estado sólido, una SSD, 
 son solo espacio de almacenamiento. 
 >> En realidad no podemos hacer nada con los datos que están en el disco duro, 
 o en una unidad de estado sólido. 
 Para cambiar realmente los datos o moverlos, 
 tenemos que moverlo a RAM, memoria de acceso aleatorio. 
 Ahora RAM, tienes mucho menos en tu computadora. 
 Es posible que tenga en algún lugar en el vecindario de 512 megabytes 
 si tiene una computadora más antigua, tal vez dos, cuatro, ocho, 16, 
 posiblemente incluso un poco más, gigabytes de RAM. 
 Eso es mucho más pequeño, pero ahí es donde existen todos los datos volátiles. 
 Ahí es donde podemos cambiar las cosas. 
 Pero cuando apagamos nuestra computadora, todos los datos en la RAM se destruyen. 
 >> Entonces es por eso que necesitamos tener un disco duro para la ubicación más permanente del mismo, 
 para que exista, sería realmente malo si cada vez que 

Chinese: 
這是您所有文件最終存在的地方， 
即使關閉計算機，也可以將其重新打開
重新啟動系統後，您會發現文件又在那裡。 
但是磁盤驅動器，例如硬盤驅動器，HDD或固態驅動器，SSD， 
只是存儲空間。 
 >>我們實際上無法對硬盤中的數據進行任何處理， 
或固態驅動器中。 
為了實際更改數據或四處移動， 
我們必須將其移至隨機存取存儲器RAM中。 
現在，RAM減少了計算機中的內存。 
您可能在512兆字節附近
如果您使用的是較舊的計算機，則可能是2、4、8、16 
可能還要多一點GB的RAM。 
因此，它要小得多，但這是所有易失性數據都存在的地方。 
那是我們可以改變事情的地方。 
但是，當我們關閉計算機時，RAM中的所有數據都會被破壞。 
 >>因此，這就是為什麼我們需要硬盤來永久固定它， 
這樣它存在-如果我們每次

English: 
And it's where all of your files ultimately live,
even when your computer is shut off, you can turn it back on
and you'll find your files are there again when you reboot your system.
But disk drives, like a hard disk drive, an HDD, or a solid state drive, an SSD,
are just storage space.
>> We can't actually do anything with the data that is in hard disk,
or in a solid state drive.
In order to actually change data or move it around,
we have to move it to RAM, random access memory.
Now RAM, you have a lot less of in your computer.
You may have somewhere in the neighborhood of 512 megabytes
if you have an older computer, to maybe two, four, eight, 16,
possibly even a little more, gigabytes of RAM.
So that's much smaller, but that's where all of the volatile data exists.
That's where we can change things.
But when we turn our computer off, all of the data in RAM is destroyed.
>> So that's why we need to have hard disk for the more permanent location of it,
so that it exists- it would be really bad if every time we

Dutch: 
 En het is waar al uw bestanden uiteindelijk leven, 
 zelfs als uw computer is uitgeschakeld, kunt u deze weer inschakelen 
 en je zult zien dat je bestanden er weer zijn wanneer je je systeem herstart. 
 Maar schijfstations, zoals een harde schijf, een harde schijf of een solid-state schijf, een SSD, 
 zijn slechts opslagruimte. 
 >> We kunnen eigenlijk niets doen met de gegevens op de harde schijf, 
 of in een SSD-station. 
 Om gegevens daadwerkelijk te wijzigen of te verplaatsen, 
 we moeten het verplaatsen naar RAM, willekeurig toegankelijk geheugen. 
 Nu RAM, je hebt veel minder in je computer. 
 Je hebt misschien ergens in de buurt van 512 megabytes 
 als je een oudere computer hebt, misschien twee, vier, acht, 16, 
 mogelijk zelfs een beetje meer, gigabytes RAM. 
 Dat is dus veel kleiner, maar dat is waar alle vluchtige gegevens bestaan. 
 Dat is waar we dingen kunnen veranderen. 
 Maar als we onze computer uitzetten, worden alle gegevens in het RAM vernietigd. 
 >> Daarom hebben we een harde schijf nodig voor de meer permanente locatie ervan, 
 zodat het bestaat - het zou heel erg zijn als we elke keer 

Modern Greek (1453-): 
 Και είναι όπου όλα τα αρχεία σας τελικά ζουν, 
 ακόμα και όταν ο υπολογιστής σας είναι απενεργοποιημένος, μπορείτε να τον ενεργοποιήσετε ξανά 
 και θα βρείτε τα αρχεία σας εκεί πάλι όταν κάνετε επανεκκίνηση του συστήματός σας. 
 Ωστόσο, οι μονάδες δίσκου, όπως μια μονάδα σκληρού δίσκου, ένας σκληρός δίσκος ή μια μονάδα SSD, ένα SSD, 
 είναι απλά χώρος αποθήκευσης. 
 >> Δεν μπορούμε πραγματικά να κάνουμε τίποτα με τα δεδομένα που βρίσκονται στο σκληρό δίσκο, 
 ή σε μονάδα SSD. 
 Προκειμένου να αλλάξετε δεδομένα ή να τα μετακινήσετε, 
 πρέπει να το μεταφέρουμε σε μνήμη τυχαίας προσπέλασης RAM. 
 Τώρα RAM, έχετε πολύ λιγότερο στον υπολογιστή σας. 
 Μπορεί να έχετε κάπου στην περιοχή των 512 megabytes 
 εάν έχετε έναν παλαιότερο υπολογιστή, ίσως δύο, τέσσερα, οκτώ, 16, 
 ίσως ακόμη και λίγο περισσότερο, gigabytes μνήμης RAM. 
 Έτσι είναι πολύ μικρότερο, αλλά εκεί υπάρχουν όλα τα πτητικά δεδομένα. 
 Εκεί μπορούμε να αλλάξουμε τα πράγματα. 
 Αλλά όταν απενεργοποιήσουμε τον υπολογιστή μας, όλα τα δεδομένα στη μνήμη RAM καταστρέφονται. 
 >> Γι 'αυτό πρέπει να έχουμε σκληρό δίσκο για την πιο μόνιμη θέση του, 
 έτσι ώστε να υπάρχει - θα ήταν πολύ κακό αν κάθε φορά 

Indonesian: 
 Dan di situlah semua file Anda pada akhirnya tinggal, 
 bahkan ketika komputer Anda mati, Anda dapat menyalakannya kembali 
 dan Anda akan menemukan file Anda ada di sana lagi ketika Anda reboot sistem Anda. 
 Tetapi disk drive, seperti hard disk drive, HDD, atau solid state drive, SSD, 
 hanya ruang penyimpanan. 
 >> Kami tidak bisa melakukan apa pun dengan data yang ada di hard disk, 
 atau dalam solid state drive. 
 Untuk benar-benar mengubah data atau memindahkannya, 
 kita harus memindahkannya ke RAM, memori akses acak. 
 Sekarang RAM, Anda memiliki jauh lebih sedikit di komputer Anda. 
 Anda mungkin memiliki tempat di lingkungan 512 megabyte 
 jika Anda memiliki komputer yang lebih tua, mungkin dua, empat, delapan, 16, 
 bahkan mungkin sedikit lebih, gigabyte RAM. 
 Jadi itu jauh lebih kecil, tetapi di situlah semua data volatil ada. 
 Di situlah kita dapat mengubah banyak hal. 
 Tetapi ketika kita mematikan komputer, semua data dalam RAM dihancurkan. 
 >> Jadi itu sebabnya kita perlu memiliki hard disk untuk lokasi yang lebih permanen, 
 sehingga itu ada - akan sangat buruk jika setiap kali kita 

Portuguese: 
 E é onde todos os seus arquivos permanecem, 
 mesmo quando o computador está desligado, você pode ligá-lo novamente 
 e você encontrará seus arquivos novamente quando reiniciar o sistema. 
 Porém, unidades de disco, como uma unidade de disco rígido, um HDD ou uma unidade de estado sólido, um SSD, 
 são apenas espaço de armazenamento. 
 >> Na verdade, não podemos fazer nada com os dados que estão no disco rígido, 
 ou em uma unidade de estado sólido. 
 Para realmente alterar dados ou movê-los, 
 temos que movê-lo para a RAM, memória de acesso aleatório. 
 Agora, RAM, você tem muito menos no seu computador. 
 Você pode ter algum lugar na faixa de 512 megabytes 
 se você tiver um computador antigo, talvez dois, quatro, oito, 16, 
 possivelmente um pouco mais, gigabytes de RAM. 
 Portanto, é muito menor, mas é onde todos os dados voláteis existem. 
 É aí que podemos mudar as coisas. 
 Mas quando desligamos o computador, todos os dados na RAM são destruídos. 
 >> É por isso que precisamos ter um disco rígido para a localização mais permanente dele, 
 para que exista - seria muito ruim se toda vez que 

Arabic: 
 وهو المكان الذي تعيش فيه جميع ملفاتك في النهاية ، 
 حتى عند إيقاف تشغيل الكمبيوتر ، يمكنك إعادة تشغيله 
 وستجد ملفاتك هناك مرة أخرى عند إعادة تشغيل نظامك. 
 لكن محركات الأقراص ، مثل محرك الأقراص الثابتة أو محرك الأقراص الثابتة أو محرك الأقراص ذي الحالة الصلبة أو SSD ، 
 هي مجرد مساحة تخزين. 
 >> لا يمكننا فعل أي شيء بالبيانات الموجودة على القرص الصلب ، 
 أو في محرك أقراص ذي حالة صلبة. 
 من أجل تغيير البيانات أو نقلها ، 
 علينا نقلها إلى ذاكرة الوصول العشوائي ، ذاكرة الوصول العشوائي. 
 الآن ذاكرة الوصول العشوائي ، لديك الكثير أقل في جهاز الكمبيوتر الخاص بك. 
 قد يكون لديك مكان في حي 512 ميغا بايت 
 إذا كان لديك جهاز كمبيوتر أقدم ، ربما إلى اثنين أو أربعة أو ثمانية أو 16 ، 
 ربما أكثر بقليل من غيغابايت من ذاكرة الوصول العشوائي. 
 هذا أصغر بكثير ، ولكن هذا هو المكان الذي توجد فيه جميع البيانات المتقلبة. 
 هذا حيث يمكننا تغيير الأشياء. 
 ولكن عند إيقاف تشغيل جهاز الكمبيوتر الخاص بنا ، يتم إتلاف جميع البيانات الموجودة في ذاكرة الوصول العشوائي. 
 >> لهذا السبب نحتاج أن يكون لدينا قرص صلب لموقعه الدائم ، 
 حتى يكون موجودًا - سيكون سيئًا حقًا إذا كنا في كل مرة 

Russian: 
 выключил наш компьютер, все файлы в нашей системе были уничтожены. 
 Итак, мы работаем внутри оперативной памяти. 
 И каждый раз, когда мы говорим о памяти, в значительной степени, в CS50, 
 мы говорим о оперативной памяти, а не о жестком диске. 
 >> Поэтому, когда мы перемещаем вещи в память, это занимает определенное количество места. 
 Все типы данных, с которыми мы работали 
 занимают различное количество места в оперативной памяти. 
 Таким образом, каждый раз, когда вы создаете целочисленную переменную, четыре байта памяти 
 выделены в оперативной памяти, так что вы можете работать с этим целым числом. 
 Вы можете объявить целое число, изменить его, назначить его 
 до значения 10, увеличенного на единицу, и так далее, и так далее. 
 Все, что должно произойти в оперативной памяти, и вы получите четыре байта 
 работать с каждым целым числом, которое вы создаете. 
 >> Каждый созданный вами персонаж получает один байт. 
 Вот только сколько места нужно для хранения персонажа. 
 Каждое число с плавающей точкой, действительное число, получает четыре байта 
 если это не с плавающей точкой двойной точности 
 номер, который позволяет иметь более точные или более цифры 
 после десятичной точки без потери точности, 

Korean: 
 컴퓨터를 끄고 시스템의 모든 파일을 삭제했습니다. 
 그래서 우리는 RAM 내부에서 작업합니다. 
 CS50에서 메모리에 대해 이야기 할 때마다 
 우리는 하드 디스크가 아니라 RAM에 대해 이야기하고 있습니다. 
 >> 그래서 우리가 메모리로 물건을 옮길 때, 그것은 어느 정도의 공간을 차지합니다. 
 우리가 작업 한 모든 데이터 유형 
 RAM에서 다른 공간을 차지합니다. 
 정수 변수를 만들 때마다 4 바이트의 메모리 
 그 정수로 작업 할 수 있도록 RAM에 따로 설정되어 있습니다. 
 정수를 선언하고 변경하고 할당 할 수 있습니다 
 1 씩 증가하는 등의 값으로 
 RAM에서 발생해야하는 모든 것은 4 바이트입니다. 
 생성하는 모든 정수에 대해 작업합니다. 
 >> 생성하는 모든 문자는 1 바이트를 얻습니다. 
 캐릭터를 저장하는 데 필요한 공간이 얼마입니까? 
 실수는 실수로 4 바이트를 얻는다 
 배정 밀도 부동 소수점이 아닌 한 
 더 정확하거나 더 많은 숫자를 가질 수있는 숫자 
 소수점 이하로 정밀도를 잃지 않고 

Indonesian: 
 mematikan komputer kami, setiap file di sistem kami dilenyapkan. 
 Jadi kami bekerja di dalam RAM. 
 Dan setiap kali kita berbicara tentang memori, cukup banyak, di CS50, 
 kita berbicara tentang RAM, bukan hard disk. 
 >> Jadi, ketika kita memindahkan berbagai hal ke dalam memori, dibutuhkan sejumlah ruang. 
 Semua tipe data yang telah kami kerjakan 
 membutuhkan jumlah ruang RAM yang berbeda. 
 Jadi setiap kali Anda membuat variabel integer, empat byte memori 
 dikesampingkan dalam RAM sehingga Anda dapat bekerja dengan integer itu. 
 Anda dapat mendeklarasikan integer, mengubahnya, menetapkannya 
 ke nilai 10 bertambah satu, seterusnya dan seterusnya. 
 Semua itu perlu terjadi dalam RAM, dan Anda mendapatkan empat byte 
 untuk bekerja dengan untuk setiap bilangan bulat yang Anda buat. 
 >> Setiap karakter yang Anda buat mendapat satu byte. 
 Itulah seberapa banyak ruang yang dibutuhkan untuk menyimpan karakter. 
 Setiap float, bilangan real, mendapat empat byte 
 kecuali itu adalah floating point presisi ganda 
 angka, yang memungkinkan Anda untuk memiliki angka yang lebih tepat atau lebih banyak 
 setelah titik desimal tanpa kehilangan presisi, 

Modern Greek (1453-): 
 απενεργοποίησε τον υπολογιστή μας, κάθε αρχείο στο σύστημά μας διαγράφηκε. 
 Έτσι δουλεύουμε μέσα στο RAM. 
 Και κάθε φορά που μιλάμε για μνήμη, λίγο πολύ, στο CS50, 
 μιλάμε για μνήμη RAM, όχι για σκληρό δίσκο. 
 >> Έτσι, όταν μεταφέρουμε τα πράγματα στη μνήμη, καταλαμβάνει ένα συγκεκριμένο χώρο. 
 Όλοι οι τύποι δεδομένων με τους οποίους συνεργαζόμαστε 
 απορροφούν διαφορετικές ποσότητες χώρου στη μνήμη RAM. 
 Έτσι κάθε φορά που δημιουργείτε μια μεταβλητή ακέραιων αριθμών, τέσσερα bytes μνήμης 
 παρατίθενται στην μνήμη RAM ώστε να μπορείτε να εργαστείτε με αυτόν τον ακέραιο αριθμό. 
 Μπορείτε να δηλώσετε τον ακέραιο αριθμό, να το αλλάξετε, να την εκχωρήσετε 
 σε μια τιμή 10 αυξανόμενη κατά ένα, ούτω καθεξής και ούτω καθεξής. 
 Το μόνο που χρειάζεται να συμβεί στη μνήμη RAM και παίρνετε τέσσερα byte 
 να εργαστείτε με για κάθε ακέραιο που δημιουργείτε. 
 >> Κάθε χαρακτήρας που δημιουργείτε παίρνει ένα byte. 
 Αυτό είναι ακριβώς πόσο χώρο χρειάζεται για να αποθηκεύσετε ένα χαρακτήρα. 
 Κάθε πλωτήρας, ένας πραγματικός αριθμός, παίρνει τέσσερα bytes 
 εκτός αν είναι ένα πλωτό σημείο διπλής ακρίβειας 
 αριθμός, που σας επιτρέπει να έχετε ακριβέστερα ή περισσότερα ψηφία 
 μετά την υποδιαστολή χωρίς να χάσει την ακρίβεια, 

Turkish: 
 bilgisayarımızı kapattı, sistemimizdeki her dosya silindi. 
 Bu yüzden RAM'in içinde çalışıyoruz. 
 Ve her zaman CS50'de bellek hakkında konuştuğumuzda, 
 sabit diskten değil RAM'den bahsediyoruz. 
 >> Yani bir şeyi belleğe taşıdığımızda belli bir yer kaplıyor. 
 Üzerinde çalıştığımız tüm veri türleri 
 RAM'de farklı miktarlarda yer kaplar. 
 Yani her tam sayı değişkeni oluşturduğunuzda dört bayt bellek 
 RAM'de bir kenara bırakılır, böylece bu tamsayı ile çalışabilirsiniz. 
 Tamsayıyı bildirebilir, değiştirebilir, atayabilirsiniz 
 bir artırılmış bir değere, vb. 
 RAM'de olması gereken her şey ve dört bayt alırsınız 
 oluşturduğunuz her tamsayı için birlikte çalışmak. 
 >> Oluşturduğunuz her karakter bir bayt alır. 
 Bir karakteri saklamak için ne kadar alan gerekir. 
 Her float, gerçek bir sayı, dört bayt alır 
 çift ​​hassasiyetli kayar nokta olmadıkça 
 Daha kesin veya daha fazla basamağa sahip olmanızı sağlayan sayı 
 ondalık noktadan sonra hassasiyet kaybetmeden, 

Arabic: 
 أغلق جهاز الكمبيوتر الخاص بنا ، تم طمس كل ملف في نظامنا. 
 لذلك نحن نعمل داخل ذاكرة الوصول العشوائي. 
 وفي كل مرة نتحدث عن الذاكرة في CS50 ، 
 نحن نتحدث عن ذاكرة الوصول العشوائي ، وليس القرص الصلب. 
 >> لذا عندما ننقل الأشياء إلى الذاكرة ، فإنها تأخذ مساحة معينة. 
 جميع أنواع البيانات التي كنا نعمل معها 
 تشغل مساحات مختلفة في ذاكرة الوصول العشوائي. 
 لذلك في كل مرة تقوم فيها بإنشاء متغير صحيح ، أربعة بايت من الذاكرة 
 يتم تخصيصها في ذاكرة الوصول العشوائي حتى تتمكن من العمل مع هذا العدد الصحيح. 
 يمكنك التصريح عن العدد الصحيح وتغييره وتعيينه 
 إلى قيمة 10 تتزايد بواحد ، وهكذا دواليك. 
 كل ما يجب أن يحدث في ذاكرة الوصول العشوائي ، تحصل على أربعة بايت 
 للعمل مع كل عدد صحيح تقوم بإنشائه. 
 >> كل حرف تقوم بإنشائه يحصل على بايت واحد. 
 هذا هو مقدار المساحة اللازمة لتخزين الشخصية. 
 كل تعويم ، رقم حقيقي ، يحصل على أربعة بايت 
 ما لم تكن نقطة عائمة مزدوجة الدقة 
 الرقم ، الذي يسمح لك بالحصول على أرقام أكثر دقة أو أكثر 
 بعد الفاصلة العشرية دون فقدان الدقة ، 

German: 
 schaltete unseren Computer aus, jede Datei in unserem System wurde ausgelöscht. 
 Wir arbeiten also im RAM. 
 Und jedes Mal, wenn wir in CS50 über Speicher sprechen, 
 Wir sprechen von RAM, nicht von Festplatte. 
 >> Wenn wir also Dinge in Erinnerung behalten, nimmt sie eine gewisse Menge Platz ein. 
 Alle Datentypen, mit denen wir gearbeitet haben 
 belegen unterschiedlich viel Speicherplatz im RAM. 
 Jedes Mal, wenn Sie eine Ganzzahlvariable erstellen, werden vier Byte Speicher benötigt 
 werden im RAM beiseite gelegt, damit Sie mit dieser Ganzzahl arbeiten können. 
 Sie können die Ganzzahl deklarieren, ändern, zuweisen 
 auf einen Wert 10 erhöht um eins, so weiter und so fort. 
 Alles, was im RAM passieren muss, und Sie erhalten vier Bytes 
 für jede von Ihnen erstellte Ganzzahl zu arbeiten. 
 >> Jedes von Ihnen erstellte Zeichen erhält ein Byte. 
 So viel Platz wird benötigt, um einen Charakter zu speichern. 
 Jeder Float, eine reelle Zahl, erhält vier Bytes 
 es sei denn, es handelt sich um einen Gleitkomma mit doppelter Genauigkeit 
 Zahl, mit der Sie präzisere oder genauere Ziffern eingeben können 
 nach dem Dezimalpunkt ohne Genauigkeitsverlust, 

English: 
turned our computer off, every file in our system was obliterated.
So we work inside of RAM.
And every time we're talking about memory, pretty much, in CS50,
we're talking about RAM, not hard disk.
>> So when we move things into memory, it takes up a certain amount of space.
All of the data types that we've been working with
take up different amounts of space in RAM.
So every time you create an integer variable, four bytes of memory
are set aside in RAM so you can work with that integer.
You can declare the integer, change it, assign it
to a value 10 incremented by one, so on and so on.
All that needs to happen in RAM, and you get four bytes
to work with for every integer that you create.
>> Every character you create gets one byte.
That's just how much space is needed to store a character.
Every float, a real number, gets four bytes
unless it's a double precision floating point
number, which allows you to have more precise or more digits
after the decimal point without losing precision,

French: 
 éteint notre ordinateur, chaque fichier de notre système a été effacé. 
 Nous travaillons donc à l'intérieur de la RAM. 
 Et chaque fois que nous parlons de mémoire, à peu près, dans CS50, 
 nous parlons de RAM, pas de disque dur. 
 >> Donc, quand nous remuons des choses dans la mémoire, cela prend une certaine quantité d'espace. 
 Tous les types de données avec lesquels nous avons travaillé 
 prendre différentes quantités d'espace dans la RAM. 
 Donc, chaque fois que vous créez une variable entière, quatre octets de mémoire 
 sont mis de côté dans la RAM afin que vous puissiez travailler avec cet entier. 
 Vous pouvez déclarer l'entier, le changer, l'affecter 
 à une valeur 10 incrémentée de un, etc., etc. 
 Tout ce qui doit arriver en RAM, et vous obtenez quatre octets 
 de travailler avec pour chaque entier que vous créez. 
 >> Chaque personnage que vous créez reçoit un octet. 
 C'est juste combien d'espace est nécessaire pour stocker un personnage. 
 Chaque flotteur, un nombre réel, obtient quatre octets 
 sauf s'il s'agit d'une virgule flottante double précision 
 nombre, qui vous permet d'avoir des chiffres plus précis ou plus 
 après la virgule décimale sans perdre en précision, 

Chinese: 
关闭计算机，系统中的每个文件都被清除。 
因此，我们在RAM内部进行工作。 
每当我们在CS50中谈论内存时， 
我们说的是RAM，而不是硬盘。 
 >>因此，当我们将事物移入内存时，它将占用一定的空间。 
我们一直在使用的所有数据类型
在RAM中占用不同数量的空间。 
因此，每次创建整数变量时，都会有四个字节的内存
在RAM中预留出来，因此您可以使用该整数。 
您可以声明整数，对其进行更改，对其进行赋值
到值10加一，依此类推。 
所有需要在RAM中发生的事情，您得到四个字节
为您创建的每个整数使用。 
 >>您创建的每个字符都会得到一个字节。 
这就是存储字符所需的空间。 
每个浮点数（一个实数）获取四个字节
除非它是双精度浮点数
数字，使您可以输入更精确的数字
小数点后不损失精度， 

Hindi: 
 हमारे कंप्यूटर को बंद कर दिया गया, हमारे सिस्टम की हर फाइल तिरछी थी। 
 इसलिए हम RAM के अंदर काम करते हैं। 
 और हर बार जब हम मेमोरी के बारे में बात करते हैं, तो बहुत ज्यादा, CS50 में, 
 हम रैम की बात कर रहे हैं, हार्ड डिस्क की नहीं। 
 >> इसलिए जब हम चीजों को मेमोरी में स्थानांतरित करते हैं, तो यह एक निश्चित मात्रा में जगह लेता है। 
 वे सभी डेटा प्रकार, जिनके साथ हम काम कर रहे हैं 
 रैम में अलग-अलग मात्रा में जगह लें। 
 तो हर बार जब आप एक पूर्णांक चर बनाते हैं, तो मेमोरी के चार बाइट्स 
 रैम में अलग सेट किए गए हैं ताकि आप उस पूर्णांक के साथ काम कर सकें। 
 आप पूर्णांक घोषित कर सकते हैं, इसे बदल सकते हैं, असाइन कर सकते हैं 
 एक मूल्य पर 10 की वृद्धि हुई है, और इसी तरह। 
 रैम में सभी की जरूरत होती है, और आपको चार बाइट्स मिलते हैं 
 आपके द्वारा बनाए गए प्रत्येक पूर्णांक के साथ काम करना। 
 >> आपके द्वारा बनाए गए प्रत्येक चरित्र को एक बाइट मिलती है। 
 किसी किरदार को स्टोर करने के लिए बस कितनी जगह की जरूरत होती है। 
 प्रत्येक फ्लोट, एक वास्तविक संख्या, चार बाइट्स प्राप्त करता है 
 जब तक यह एक डबल सटीक फ़्लोटिंग पॉइंट नहीं है 
 संख्या, जो आपको अधिक सटीक या अधिक अंक देने की अनुमति देती है 
 परिशुद्धता खोने के बिना दशमलव बिंदु के बाद, 

Japanese: 
私たちのコンピューターをオフにすると、システム内のすべてのファイルが消去されました。 
したがって、RAM内で作業します。 
そして、私たちがメモリについて話すたびに、CS50では、 
ハードディスクではなく、RAMのことです。 
 >>だから、物事をメモリに移すとき、それはある量のスペースをとります。 
これまで扱ってきたすべてのデータ型
 RAMのさまざまな容量を使用します。 
したがって、整数変数を作成するたびに、4バイトのメモリ
 RAMに確保されているので、その整数で作業できます。 
整数を宣言、変更、割り当てできます
 1ずつ増加する値10に、というように続きます。 
 RAMですべての処理を行う必要があり、4バイトを取得します
作成するすべての整数を処理します。 
 >>作成するすべての文字は1バイトを取得します。 
これは、キャラクターを格納するために必要なスペースの量です。 
すべての浮動小数点数、実数は4バイトを取得します
倍精度浮動小数点でない限り
数値。これにより、より正確なまたはより多くの桁を持つことができます。 
小数点以下の精度を失うことなく、 

Spanish: 
 apagó nuestra computadora, cada archivo en nuestro sistema fue borrado. 
 Entonces trabajamos dentro de la RAM. 
 Y cada vez que hablamos de memoria, más o menos, en CS50, 
 Estamos hablando de RAM, no de disco duro. 
 >> Entonces, cuando trasladamos cosas a la memoria, ocupa una cierta cantidad de espacio. 
 Todos los tipos de datos con los que hemos estado trabajando 
 ocupan diferentes cantidades de espacio en la RAM. 
 Entonces, cada vez que crea una variable entera, cuatro bytes de memoria 
 se reservan en RAM para que pueda trabajar con ese número entero. 
 Puedes declarar el número entero, cambiarlo, asignarlo 
 a un valor 10 incrementado en uno, y así sucesivamente. 
 Todo lo que tiene que pasar en la RAM, y obtienes cuatro bytes 
 para trabajar con cada entero que crees. 
 >> Cada personaje que creas tiene un byte. 
 Eso es cuánto espacio se necesita para almacenar un personaje. 
 Cada flotante, un número real, obtiene cuatro bytes 
 a menos que sea un punto flotante de doble precisión 
 número, que le permite tener dígitos más precisos o más 
 después del punto decimal sin perder precisión, 

Italian: 
 spento il nostro computer, ogni file nel nostro sistema era cancellato. 
 Quindi lavoriamo all'interno della RAM. 
 E ogni volta che parliamo di memoria, praticamente, in CS50, 
 stiamo parlando di RAM, non del disco rigido. 
 >> Quindi quando spostiamo le cose nella memoria, occupa una certa quantità di spazio. 
 Tutti i tipi di dati con cui abbiamo lavorato 
 occupa diverse quantità di spazio nella RAM. 
 Quindi ogni volta che crei una variabile intera, quattro byte di memoria 
 sono messi da parte nella RAM in modo da poter lavorare con quel numero intero. 
 Puoi dichiarare l'intero, cambiarlo, assegnarlo 
 ad un valore 10 incrementato di uno, così via e così via. 
 Tutto ciò che deve accadere nella RAM e ottieni quattro byte 
 per lavorare con ogni numero intero che crei. 
 >> Ogni carattere che crei ottiene un byte. 
 Questo è solo lo spazio necessario per conservare un personaggio. 
 Ogni float, un numero reale, ottiene quattro byte 
 a meno che non sia un punto mobile a doppia precisione 
 numero, che consente di avere cifre più precise o più 
 dopo il punto decimale senza perdere precisione, 

Portuguese: 
 desligou o computador, todos os arquivos em nosso sistema foram apagados. 
 Então, trabalhamos dentro da RAM. 
 E toda vez que estamos falando sobre memória, basicamente, no CS50, 
 estamos falando de RAM, não de disco rígido. 
 >> Então, quando movemos as coisas para a memória, ela ocupa uma certa quantidade de espaço. 
 Todos os tipos de dados com os quais trabalhamos 
 ocupam diferentes quantidades de espaço na RAM. 
 Então, toda vez que você cria uma variável inteira, quatro bytes de memória 
 são reservados na RAM para que você possa trabalhar com esse número inteiro. 
 Você pode declarar o número inteiro, alterá-lo, atribuí-lo 
 para um valor 10 incrementado por um, e assim por diante. 
 Tudo o que precisa acontecer na RAM e você recebe quatro bytes 
 para trabalhar para cada número inteiro que você criar. 
 >> Todo personagem que você cria recebe um byte. 
 É exatamente quanto espaço é necessário para armazenar um personagem. 
 Todo flutuador, um número real, recebe quatro bytes 
 a menos que seja um ponto flutuante de precisão dupla 
 número, que permite que você tenha dígitos mais precisos ou mais 
 após o ponto decimal sem perder a precisão, 

Chinese: 
關閉計算機，系統中的每個文件都被清除。 
因此，我們在RAM內部進行工作。 
每當我們在CS50中談論內存時， 
我們說的是RAM，而不是硬盤。 
 >>因此，當我們將事物移入內存時，它將佔用一定的空間。 
我們一直在使用的所有數據類型
在RAM中佔用不同數量的空間。 
因此，每次創建整數變量時，都會有四個字節的內存
在RAM中預留出來，因此您可以使用該整數。 
您可以聲明整數，對其進行更改，對其進行賦值
到值10加一，依此類推。 
所有需要在RAM中發生的事情，您得到四個字節
為您創建的每個整數使用。 
 >>您創建的每個字符都會得到一個字節。 
這就是存儲字符所需的空間。 
每個浮點數（一個實數）獲取四個字節
除非它是雙精度浮點數
數字，使您可以輸入更精確的數字
小數點後不損失精度， 

Dutch: 
 zette onze computer uit, elk bestand in ons systeem werd vernietigd. 
 Dus we werken binnen RAM. 
 En elke keer dat we het over geheugen hebben, vrijwel in CS50, 
 we hebben het over RAM, niet over de harde schijf. 
 >> Dus wanneer we dingen in het geheugen verplaatsen, neemt het een bepaalde hoeveelheid ruimte in beslag. 
 Alle gegevenstypen waarmee we hebben gewerkt 
 neem verschillende hoeveelheden ruimte in RAM in. 
 Dus elke keer dat u een integer-variabele maakt, vier bytes geheugen 
 worden gereserveerd in RAM, zodat u met dat gehele getal kunt werken. 
 U kunt het gehele getal declareren, wijzigen, toewijzen 
 tot een waarde van 10 verhoogd met één, enzovoort, enzovoort. 
 Dat moet allemaal in het RAM gebeuren en je krijgt vier bytes 
 om mee te werken voor elk geheel getal dat u maakt. 
 >> Elk personage dat je maakt, krijgt één byte. 
 Dat is precies hoeveel ruimte er nodig is om een ​​personage op te slaan. 
 Elke float, een echt getal, krijgt vier bytes 
 tenzij het een drijvende komma met dubbele precisie is 
 nummer, waarmee u nauwkeuriger of meer cijfers kunt hebben 
 achter de komma zonder de nauwkeurigheid te verliezen, 

Arabic: 
 والتي تشغل ثمانية بايت من الذاكرة. 
 تستحوذ أيضًا على صفقات طويلة ، أعداد صحيحة كبيرة جدًا ، على ثمانية بايت من الذاكرة. 
 كم بايت من الذاكرة تستهلكها السلاسل؟ 
 حسنًا ، لنضع دبوسًا في هذا السؤال في الوقت الحالي ، ولكننا سنعود إليه. 
 عودة إلى فكرة الذاكرة كمجموعة كبيرة من الخلايا بحجم البايت. 
 هذا كل ما في الأمر ، إنها مجرد مجموعة كبيرة من الخلايا ، 
 تمامًا مثل أي مجموعة أخرى تعرفها وترى ، 
 باستثناء كل عنصر هو عرض بايت واحد. 
 تمامًا مثل المصفوفة ، كل عنصر له عنوان. 
 لكل عنصر في المصفوفة فهرس ، ونحن 
 يمكن استخدام هذا الفهرس للقيام بما يسمى الوصول العشوائي على الصفيف. 
 لا يجب أن نبدأ في بداية المصفوفة ، 
 التكرار من خلال كل عنصر منه ، 
 للعثور على ما نبحث عنه. 
 يمكننا أن نقول فقط ، أريد الوصول إلى العنصر الخامس عشر أو العنصر المائة. 
 ويمكنك فقط تمرير هذا الرقم والحصول على القيمة التي تبحث عنها. 
 >> وبالمثل كل عنوان في الذاكرة لديه عنوان. 
 لذا قد تبدو ذاكرتك شيئًا كهذا. 

Japanese: 
これはメモリの8バイトを占有します。 
 long long、本当に大きな整数も、8バイトのメモリを消費します。 
文字列は何バイトのメモリを使用しますか？ 
さて、とりあえずその質問にピンを付けましょう。しかし、それについては後で戻ってきます。 
 >>では、メモリのバイトサイズのセルの大きな配列としてのこの考えに戻ります。 
それが本当にすべてです、それは単なるセルの巨大な配列であり、 
よく知っている他のアレイと同じように、 
すべての要素が1バイト幅であることを除いて。 
そして配列と同じように、すべての要素にはアドレスがあります。 
配列のすべての要素にはインデックスがあり、 
そのインデックスを使用して、配列に対していわゆるランダムアクセスを実行できます。 
配列の先頭から始める必要はありませんが、 
そのすべての要素を繰り返し、 
私たちが探しているものを見つけるために。 
 15番目の要素または100番目の要素に到達したいだけです。 
そして、その数値を渡すだけで、探している値を取得できます。 
 >>同様に、メモリ内のすべての場所にアドレスがあります。 
だからあなたの記憶はこのようなものになるかもしれません。 

German: 
 die acht Bytes Speicher belegen. 
 Lange Longs, wirklich große Ganzzahlen, belegen ebenfalls acht Byte Speicher. 
 Wie viele Speicherbytes belegen Zeichenfolgen? 
 Lassen Sie uns diese Frage erst einmal anheften, aber wir werden darauf zurückkommen. 
 >> Zurück zu dieser Idee des Speichers als einer großen Anzahl von Zellen in Byte-Größe. 
 Das ist wirklich alles, es ist nur eine riesige Anzahl von Zellen, 
 genau wie jedes andere Array, mit dem Sie vertraut sind und das Sie sehen, 
 außer dass jedes Element ein Byte breit ist. 
 Und genau wie ein Array hat jedes Element eine Adresse. 
 Jedes Element eines Arrays hat einen Index, und wir 
 kann diesen Index verwenden, um einen sogenannten Direktzugriff auf das Array durchzuführen. 
 Wir müssen nicht am Anfang des Arrays beginnen, 
 durch jedes einzelne Element davon iterieren, 
 um zu finden, wonach wir suchen. 
 Wir können nur sagen, ich möchte zum 15. oder 100. Element gelangen. 
 Und Sie können einfach diese Nummer eingeben und den Wert erhalten, den Sie suchen. 
 >> Ebenso hat jeder Speicherort eine Adresse. 
 Ihr Gedächtnis könnte also ungefähr so ​​aussehen. 

Chinese: 
占用八个字节的内存。 
长整型（确实是大整数）也占用了八个字节的内存。 
字符串占用多少内存空间？ 
好吧，让我们暂时在这个问题上打一个针，但我们将回到它。 
 >>因此，将存储作为字节大小的单元的大数组返回到这个想法。 
这就是全部，只是大量的单元格， 
就像您熟悉并看到的任何其他数组一样， 
除了每个元素都是一个字节宽。 
就像数组一样，每个元素都有一个地址。 
数组的每个元素都有一个索引，我们
可以使用该索引在阵列上执行所谓的随机访问。 
我们不必从数组的开头开始， 
遍历每个元素， 
找到我们想要的东西。 
我们可以说，我想到达第15个元素或第100个元素。 
您只需传递该数字即可获得您想要的价值。 
 >>同样，内存中的每个位置都有一个地址。 
因此，您的记忆可能看起来像这样。 

Russian: 
 которые занимают восемь байтов памяти. 
 Длинные long, действительно большие целые числа, также занимают восемь байтов памяти. 
 Сколько байтов памяти занимают строки? 
 Что ж, давайте пока вставим точку в этом вопросе, но вернемся к нему. 
 >> Итак, вернемся к этой идее памяти как большого массива байтовых ячеек. 
 Это действительно все, это просто огромное количество клеток, 
 как и любой другой массив, с которым вы знакомы и видите, 
 за исключением того, что каждый элемент имеет ширину в один байт. 
 И так же, как массив, каждый элемент имеет адрес. 
 Каждый элемент массива имеет индекс, и мы 
 можно использовать этот индекс для так называемого произвольного доступа к массиву. 
 Нам не нужно начинать с начала массива, 
 перебирать каждый его элемент, 
 чтобы найти то, что мы ищем. 
 Мы можем просто сказать, что я хочу добраться до 15-го элемента или 100-го элемента. 
 И вы можете просто ввести это число и получить значение, которое вы ищете. 
 >> Точно так же каждое место в памяти имеет адрес. 
 Так что ваша память может выглядеть примерно так. 

Dutch: 
 die acht bytes geheugen in beslag nemen. 
 Lange longs, echt grote gehele getallen, nemen ook acht bytes geheugen in beslag. 
 Hoeveel bytes geheugen nemen strings in beslag? 
 Laten we voorlopig een speld in die vraag zetten, maar we komen er op terug. 
 >> Dus terug naar dit idee van geheugen als een grote reeks cellen van bytegrootte. 
 Dat is echt alles, het is gewoon een enorme reeks cellen, 
 net als elke andere array die u kent en ziet, 
 behalve dat elk element één byte breed is. 
 En net als een array heeft elk element een adres. 
 Elk element van een array heeft een index en wij 
 kan die index gebruiken om zogenaamde willekeurige toegang tot de array uit te voeren. 
 We hoeven niet te beginnen aan het begin van de array, 
 itereren door elk afzonderlijk element ervan, 
 om te vinden wat we zoeken. 
 We kunnen gewoon zeggen: ik wil naar het 15e element of het 100e element gaan. 
 En u kunt dat aantal gewoon doorgeven en de waarde krijgen waarnaar u op zoek bent. 
 >> Evenzo heeft elke locatie in het geheugen een adres. 
 Dus je geheugen zou er ongeveer zo uit kunnen zien. 

Turkish: 
 sekiz bayt bellek kaplar. 
 Uzun uzun, gerçekten büyük tamsayılar da sekiz bayt bellek alır. 
 Dizeler kaç bayt bellek kaplar? 
 Şimdilik bu soruya bir iğne koyalım, ama geri döneceğiz. 
 >> Büyük bir bayt boyutlu hücre dizisi olarak bu hafıza fikrine geri dönelim. 
 Gerçekten hepsi bu, sadece çok büyük bir hücre dizisi, 
 tıpkı tanıdığınız ve gördüğünüz diğer diziler gibi, 
 ancak her eleman bir bayt genişliğindedir. 
 Tıpkı bir dizi gibi, her öğenin bir adresi vardır. 
 Bir dizinin her öğesinin bir dizini vardır ve biz 
 dizinde rastgele erişim adı verilen dizini kullanabilir. 
 Dizinin başında başlamak zorunda değiliz, 
 her bir elementini yineleyerek, 
 aradığımızı bulmak için. 
 Sadece 15. elemente veya 100. elemente ulaşmak istiyorum diyebiliriz. 
 Ve sadece bu numarayı geçebilir ve aradığınız değeri elde edebilirsiniz. 
 >> Benzer şekilde bellekteki her konumun bir adresi vardır. 
 Hafızanız böyle bir şey olabilir. 

Spanish: 
 que ocupan ocho bytes de memoria. 
 Longs largos, enteros realmente grandes, también ocupan ocho bytes de memoria. 
 ¿Cuántos bytes de memoria ocupan las cadenas? 
 Bueno, pongamos un alfiler en esa pregunta por ahora, pero volveremos a ello. 
 >> Volvamos a esta idea de la memoria como una gran variedad de celdas de tamaño de byte. 
 Eso es realmente todo lo que es, es solo una gran variedad de células, 
 como cualquier otra matriz con la que estés familiarizado y veas, 
 excepto que cada elemento tiene un byte de ancho. 
 Y al igual que una matriz, cada elemento tiene una dirección. 
 Cada elemento de una matriz tiene un índice, y nosotros 
 puede usar ese índice para hacer el llamado acceso aleatorio en la matriz. 
 No tenemos que comenzar al principio de la matriz, 
 iterar a través de cada uno de sus elementos, 
 para encontrar lo que estamos buscando. 
 Solo podemos decir, quiero llegar al elemento 15 o al elemento 100. 
 Y simplemente puede pasar ese número y obtener el valor que está buscando. 
 >> De manera similar, cada ubicación en la memoria tiene una dirección. 
 Entonces su memoria podría verse más o menos así. 

French: 
 qui prennent huit octets de mémoire. 
 Les longs longs, les très grands entiers, prennent également huit octets de mémoire. 
 Combien d'octets de mémoire les chaînes prennent-elles? 
 Eh bien, mettons une épingle dans cette question pour l'instant, mais nous y reviendrons. 
 >> Revenons donc à cette idée de la mémoire comme un grand tableau de cellules de taille octet. 
 C'est vraiment tout ce que c'est, c'est juste un énorme éventail de cellules, 
 comme tout autre tableau que vous connaissez et voyez, 
 sauf que chaque élément a une largeur d'un octet. 
 Et tout comme un tableau, chaque élément a une adresse. 
 Chaque élément d'un tableau a un index, et nous 
 peut utiliser cet index pour effectuer ce que l'on appelle un accès aléatoire sur le tableau. 
 Nous n'avons pas besoin de commencer au début du tableau, 
 parcourir chaque élément de celui-ci, 
 pour trouver ce que nous recherchons. 
 Nous pouvons simplement dire, je veux arriver au 15e élément ou au 100e élément. 
 Et vous pouvez simplement passer ce nombre et obtenir la valeur que vous recherchez. 
 >> De même, chaque emplacement en mémoire a une adresse. 
 Votre mémoire pourrait donc ressembler à ceci. 

Indonesian: 
 yang memakan delapan byte memori. 
 Long long, integer yang sangat besar, juga menghabiskan delapan byte memori. 
 Berapa banyak byte memori yang digunakan oleh string? 
 Baiklah mari kita beri pin pada pertanyaan itu untuk saat ini, tetapi kita akan kembali ke sana. 
 >> Jadi kembali ke gagasan ini tentang memori sebagai array besar sel berukuran byte. 
 Itu benar-benar semua itu, itu hanya sejumlah besar sel, 
 sama seperti array lain yang Anda kenal dan lihat, 
 kecuali setiap elemen lebarnya satu byte. 
 Dan seperti halnya array, setiap elemen memiliki alamat. 
 Setiap elemen array memiliki indeks, dan kami 
 dapat menggunakan indeks itu untuk melakukan apa yang disebut akses acak pada array. 
 Kami tidak harus mulai dari awal array, 
 beralih melalui setiap elemennya, 
 untuk menemukan apa yang kita cari. 
 Kita bisa mengatakan, saya ingin sampai ke elemen ke-15 atau ke-100. 
 Dan Anda bisa memasukkan angka itu dan mendapatkan nilai yang Anda cari. 
 >> Demikian pula setiap lokasi dalam memori memiliki alamat. 
 Jadi ingatan Anda mungkin terlihat seperti ini. 

Portuguese: 
 que ocupam oito bytes de memória. 
 Longos longos, realmente grandes números inteiros, também ocupam oito bytes de memória. 
 Quantos bytes de memória as seqüências de caracteres ocupam? 
 Bem, vamos colocar um alfinete nessa pergunta por enquanto, mas voltaremos a ela. 
 >> Então, voltemos a essa ideia de memória como uma grande variedade de células do tamanho de bytes. 
 Isso é realmente tudo, é apenas uma enorme variedade de células, 
 assim como qualquer outra matriz que você conhece e vê, 
 exceto que cada elemento tem um byte de largura. 
 E, assim como uma matriz, todo elemento tem um endereço. 
 Todo elemento de uma matriz possui um índice, e nós 
 pode usar esse índice para fazer o chamado acesso aleatório na matriz. 
 Não precisamos começar no início da matriz, 
 iterar através de cada elemento, 
 para encontrar o que estamos procurando. 
 Podemos apenas dizer, eu quero chegar ao 15º elemento ou ao 100º elemento. 
 E você pode simplesmente passar esse número e obter o valor que está procurando. 
 >> Da mesma forma, todos os locais na memória têm um endereço. 
 Portanto, sua memória pode se parecer com isso. 

Chinese: 
佔用八個字節的內存。 
長整型（確實是大整數）也佔用了八個字節的內存。 
字符串佔用多少內存空間？ 
好吧，讓我們暫時在這個問題上打一個針，但我們將回到它。 
 >>因此，將存儲作為字節大小的單元的大數組返回到這個想法。 
這就是全部，只是大量的單元格， 
就像您熟悉並看到的任何其他數組一樣， 
除了每個元素都是一個字節寬。 
就像數組一樣，每個元素都有一個地址。 
數組的每個元素都有一個索引，我們
可以使用該索引在陣列上執行所謂的隨機訪問。 
我們不必從數組的開頭開始， 
遍歷每個元素， 
找到我們想要的東西。 
我們可以說，我想到達第15個元素或第100個元素。 
您只需傳遞該數字即可獲得您想要的價值。 
 >>同樣，內存中的每個位置都有一個地址。 
因此，您的記憶可能看起來像這樣。 

Korean: 
 8 바이트의 메모리를 차지합니다. 
 긴 정수, 실제로 큰 정수는 8 바이트의 메모리를 차지합니다. 
 문자열이 몇 바이트의 메모리를 차지합니까? 
 자 이제 그 질문에 핀을 넣겠습니다. 그러나 우리는 다시 돌아올 것입니다. 
 >> 바이트 크기 셀의 큰 배열 인 메모리에 대한이 아이디어로 돌아가십시오. 
 그게 전부입니다. 방대한 셀 배열 일뿐입니다. 
 익숙하고 보는 다른 어레이와 마찬가지로 
 모든 요소를 ​​제외하고는 너비가 1 바이트입니다. 
 배열과 마찬가지로 모든 요소에는 주소가 있습니다. 
 배열의 모든 요소에는 인덱스가 있으며 
 해당 인덱스를 사용하여 배열에서 소위 임의 액세스를 수행 할 수 있습니다. 
 배열의 시작 부분에서 시작할 필요는 없습니다. 
 모든 단일 요소를 반복하고 
 우리가 찾고있는 것을 찾으십시오. 
 우리는 단지 15 번째 요소 또는 100 번째 요소에 도달하고 싶다고 말할 수 있습니다. 
 그리고 당신은 그 숫자를 전달하고 당신이 찾고있는 가치를 얻을 수 있습니다. 
 >> 마찬가지로 메모리의 모든 위치에는 주소가 있습니다. 
 그래서 당신의 기억은 다음과 같습니다. 

English: 
which take up eight bytes of memory.
Long longs, really big integers, also take up eight bytes of memory.
How many bytes of memory do strings take up?
Well let's put a pin in that question for now, but we'll come back to it.
>> So back to this idea of memory as a big array of byte-sized cells.
That's really all it is, it's just a huge array of cells,
just like any other array that you're familiar with and see,
except every element is one byte wide.
And just like an array, every element has an address.
Every element of an array has an index, and we
can use that index to do so-called random access on the array.
We don't have to start at the beginning of the array,
iterate through every single element thereof,
to find what we're looking for.
We can just say, I want to get to the 15th element or the 100th element.
And you can just pass in that number and get the value you're looking for.
>> Similarly every location in memory has an address.
So your memory might look something like this.

Modern Greek (1453-): 
 που αναλαμβάνουν οκτώ bytes μνήμης. 
 Μακρύς μήκους, πραγματικά μεγάλοι ακέραιοι, παίρνουν επίσης οκτώ byte μνήμης. 
 Πόσα bytes μνήμης κάνουν οι συμβολοσειρές; 
 Λοιπόν ας βάλουμε μια καρφίτσα σε αυτό το ερώτημα προς το παρόν, αλλά θα επιστρέψουμε σε αυτό. 
 >> Επιστρέφοντας λοιπόν σε αυτήν την ιδέα της μνήμης ως μια μεγάλη ποικιλία κυψελών μεγέθους byte. 
 Αυτό είναι πραγματικά το μόνο που είναι, είναι απλώς μια τεράστια ποικιλία κυττάρων, 
 όπως κάθε άλλη σειρά που γνωρίζετε και βλέπετε, 
 εκτός από κάθε στοιχείο που είναι πλάτος ενός byte. 
 Και ακριβώς όπως ένας πίνακας, κάθε στοιχείο έχει μια διεύθυνση. 
 Κάθε στοιχείο μιας διάταξης έχει ένα ευρετήριο, και εμείς 
 μπορεί να χρησιμοποιήσει αυτόν τον δείκτη για να κάνει τη λεγόμενη τυχαία πρόσβαση στον πίνακα. 
 Δεν χρειάζεται να ξεκινήσουμε από την αρχή του πίνακα, 
 επανάληψη μέσω κάθε στοιχείου αυτού, 
 για να βρούμε αυτό που ψάχνουμε. 
 Μπορούμε απλώς να πούμε, θέλω να φτάσω στο 15ο στοιχείο ή στο 100ο στοιχείο. 
 Και μπορείτε απλά να περάσετε σε αυτόν τον αριθμό και να πάρετε την αξία που ψάχνετε. 
 >> Ομοίως, κάθε θέση στη μνήμη έχει διεύθυνση. 
 Έτσι, η μνήμη σας μπορεί να μοιάζει με κάτι τέτοιο. 

Italian: 
 che occupa otto byte di memoria. 
 I long long, numeri interi veramente grandi, occupano anche otto byte di memoria. 
 Quanti byte di memoria occupano le stringhe? 
 Bene, mettiamo una spilla in questa domanda per ora, ma torneremo su di essa. 
 >> Torniamo quindi a questa idea di memoria come un grande array di celle di dimensioni byte. 
 Questo è davvero tutto ciò che è, è solo una vasta gamma di celle, 
 proprio come qualsiasi altro array che conosci e vedi, 
 tranne che ogni elemento ha una larghezza di un byte. 
 E proprio come un array, ogni elemento ha un indirizzo. 
 Ogni elemento di un array ha un indice e noi 
 può usare quell'indice per fare il cosiddetto accesso casuale sull'array. 
 Non dobbiamo iniziare all'inizio dell'array, 
 scorrere attraverso ogni suo singolo elemento, 
 per trovare quello che stiamo cercando. 
 Possiamo solo dire che voglio arrivare al 15 ° elemento o al 100 ° elemento. 
 E puoi semplicemente passare quel numero e ottenere il valore che stai cercando. 
 >> Allo stesso modo ogni posizione in memoria ha un indirizzo. 
 Quindi la tua memoria potrebbe assomigliare a questa. 

Hindi: 
 जो स्मृति के आठ बाइट लेते हैं। 
 लंबे लंबे, वास्तव में बड़े पूर्णांक, स्मृति के आठ बाइट्स भी लेते हैं। 
 स्मृति के कितने बाइट्स तार लेते हैं? 
 अच्छा चलो अब के लिए उस प्रश्न में एक पिन लगाते हैं, लेकिन हम उस पर वापस आएंगे। 
 >> तो बाइट के आकार की कोशिकाओं के एक बड़े सरणी के रूप में स्मृति के इस विचार पर वापस जाएं। 
 वास्तव में यह सब है, यह सिर्फ कोशिकाओं का एक विशाल सरणी है, 
 किसी भी अन्य सरणी की तरह, जिससे आप परिचित हैं और देखें, 
 हर तत्व को छोड़कर एक बाइट चौड़ी है। 
 और एक सरणी की तरह, हर तत्व का एक पता होता है। 
 किसी सरणी के प्रत्येक तत्व में एक इंडेक्स होता है, और हम 
 सरणी पर तथाकथित यादृच्छिक पहुँच करने के लिए उस सूचकांक का उपयोग कर सकते हैं। 
 हमें सरणी की शुरुआत में शुरू नहीं करना है, 
 हर एक तत्व के माध्यम से पुनरावृति, 
 जिसे हम ढूंढ रहे हैं उसे खोजने के लिए। 
 हम बस कह सकते हैं, मैं 15 वें तत्व या 100 वें तत्व को प्राप्त करना चाहता हूं। 
 और आप बस उस संख्या को पास कर सकते हैं और उस मूल्य को प्राप्त कर सकते हैं जिसे आप खोज रहे हैं। 
 >> इसी तरह मेमोरी में हर लोकेशन का एक पता होता है। 
 तो आपकी याददाश्त कुछ इस तरह दिख सकती है। 

Russian: 
 Вот очень маленький кусок памяти, это 20 байтов памяти. 
 Первые 20 байтов, потому что мои адреса там внизу 
 0, 1, 2, 3 и т. д. вплоть до 19. 
 И когда я объявляю переменные и когда я начинаю работать с ними, 
 система выделит мне немного места 
 в этой памяти для работы с моими переменными. 
 Так что я могу сказать, что char c равен капиталу H. А что будет дальше? 
 Ну, система собирается выделить для меня один байт. 
 В этом случае он выбрал байт номер четыре, байт по адресу четыре, 
 и он будет хранить там букву H для меня. 
 Если я тогда скажу, что ограничение скорости Int равно 65, это 
 собираюсь выделить четыре байта памяти для меня. 
 И это будет обрабатывать эти четыре байта как единое целое 
 потому что мы работаем с целым числом здесь. 
 И там будет храниться 65. 
 >> Теперь я уже немного лгу, 
 верно, потому что мы знаем, что компьютеры работают в двоичном формате. 
 Они не обязательно понимают, что такое заглавная Н 
 или что такое 65, они понимают только двоичные, нули и единицы. 
 И так на самом деле то, что мы храним там 

German: 
 Hier ist ein sehr kleiner Speicherblock, das sind 20 Byte Speicher. 
 Die ersten 20 Bytes, weil meine Adressen dort unten sind 
 sind 0, 1, 2, 3 usw. bis zu 19. 
 Und wenn ich Variablen deklariere und anfange, mit ihnen zu arbeiten, 
 Das System wird etwas Platz für mich reservieren 
 in diesem Speicher mit meinen Variablen zu arbeiten. 
 Ich könnte also sagen, char c ist gleich Kapital H. Und was wird passieren? 
 Nun, das System wird für mich ein Byte beiseite legen. 
 In diesem Fall wählte es Byte Nummer vier, das Byte an Adresse vier, 
 und es wird den Buchstaben H für mich dort speichern. 
 Wenn ich dann sage, dass int Geschwindigkeitsbegrenzung gleich 65 ist, ist es 
 Ich werde vier Bytes Speicher für mich reservieren. 
 Und diese vier Bytes werden als eine Einheit behandelt 
 denn wir arbeiten hier mit einer ganzen Zahl. 
 Und es wird dort 65 speichern. 
 >> Jetzt erzähle ich dir schon eine kleine Lüge, 
 Richtig, weil wir wissen, dass Computer binär arbeiten. 
 Sie verstehen nicht unbedingt, was ein Kapital H ist 
 oder was eine 65 ist, verstehen sie nur Binär, Nullen und Einsen. 
 Und genau das, was wir dort aufbewahren 

Modern Greek (1453-): 
 Εδώ είναι ένα πολύ μικρό κομμάτι μνήμης, αυτό είναι 20 bytes μνήμης. 
 Τα πρώτα 20 bytes επειδή οι διευθύνσεις μου βρίσκονται στο κάτω μέρος 
 είναι 0, 1, 2, 3 και ούτω καθεξής μέχρι το 19. 
 Και όταν δηλώνω μεταβλητές και όταν αρχίζω να δουλεύω μαζί τους, 
 το σύστημα πρόκειται να διαθέσει λίγο χώρο για μένα 
 σε αυτή τη μνήμη για να δουλέψω με τις μεταβλητές μου. 
 Μπορώ να πω ότι ο char c ισούται με το κεφάλαιο H. Και τι πρόκειται να συμβεί; 
 Καλά το σύστημα πρόκειται να οριοθετήσει για μένα ένα byte. 
 Στην περίπτωση αυτή, επέλεξε το byte number four, το byte στη διεύθυνση four, 
 και πρόκειται να αποθηκεύσει την κεφαλαία γράμματος H εκεί για μένα. 
 Αν λέω έπειτα int οριακή ταχύτητα ισούται με 65, είναι 
 για να με αφήσω τέσσερις bytes μνήμης. 
 Και πρόκειται να αντιμετωπίσει αυτά τα τέσσερα byte ως μια ενιαία μονάδα 
 επειδή αυτό με το οποίο εργαζόμαστε είναι ένας ακέραιος εδώ. 
 Και θα αποθηκεύσει 65 εκεί. 
 >> Τώρα ήδη σας λέω ένα ψέμα, 
 σωστά, επειδή γνωρίζουμε ότι οι υπολογιστές λειτουργούν σε δυαδικά. 
 Δεν καταλαβαίνουν αναγκαστικά τι είναι το κεφάλαιο Η 
 ή τι είναι ένα 65, κατανοούν μόνο δυαδικά, μηδενικά και αυτά. 
 Και πράγματι αυτό που αποθηκεύουμε εκεί 

French: 
 Voici un tout petit morceau de mémoire, c'est 20 octets de mémoire. 
 Les 20 premiers octets car mes adresses en bas 
 sont 0, 1, 2, 3, et ainsi de suite jusqu'à 19. 
 Et quand je déclare des variables et quand je commence à travailler avec elles, 
 le système va me réserver de l'espace 
 dans cette mémoire pour travailler avec mes variables. 
 Donc je pourrais dire, car c est égal au capital H. Et que va-t-il se passer? 
 Eh bien, le système va me réserver un octet. 
 Dans ce cas, il a choisi l'octet numéro quatre, l'octet à l'adresse quatre, 
 et ça va stocker la lettre majuscule H là pour moi. 
 Si je dis que la limite de vitesse int est égale à 65, c'est 
 va mettre de côté quatre octets de mémoire pour moi. 
 Et ça va traiter ces quatre octets comme une seule unité 
 parce que nous travaillons ici avec un entier. 
 Et ça va en stocker 65 là-dedans. 
 >> Maintenant, je vous dis un peu un mensonge, 
 à droite, car nous savons que les ordinateurs fonctionnent en binaire. 
 Ils ne comprennent pas nécessairement ce qu'est un H majuscule 
 ou ce qu'est un 65, ils ne comprennent que les binaires, les zéros et les uns. 
 Et donc en fait ce que nous stockons là-dedans 

Spanish: 
 Aquí hay una porción muy pequeña de memoria, esto es 20 bytes de memoria. 
 Los primeros 20 bytes porque mis direcciones están en la parte inferior 
 son 0, 1, 2, 3, y así sucesivamente hasta 19. 
 Y cuando declaro variables y cuando empiezo a trabajar con ellas, 
 el sistema me reservará algo de espacio 
 en esta memoria para trabajar con mis variables. 
 Entonces podría decir, char c es igual al capital H. ¿Y qué va a pasar? 
 Bueno, el sistema me reservará un byte. 
 En este caso, eligió el byte número cuatro, el byte en la dirección cuatro, 
 y va a almacenar la letra H mayúscula allí para mí. 
 Si luego digo que el límite de velocidad int es igual a 65, es 
 me reservará cuatro bytes de memoria. 
 Y va a tratar esos cuatro bytes como una sola unidad 
 porque estamos trabajando con un número entero aquí. 
 Y va a almacenar 65 allí. 
 >> Ahora ya te estoy diciendo una mentira, 
 bien, porque sabemos que las computadoras funcionan en binario. 
 No entienden necesariamente qué es una H mayúscula 
 o lo que es un 65, solo entienden binario, ceros y unos. 
 Y así, en realidad, lo que estamos almacenando allí 

Korean: 
 여기 아주 작은 메모리 조각이 있습니다. 이것은 20 바이트의 메모리입니다. 
 내 주소가 맨 아래에 있기 때문에 처음 20 바이트 
 0, 1, 2, 3 등이 최대 19입니다. 
 변수를 선언하고 작업을 시작할 때 
 시스템은 저를 위해 약간의 공간을 남겨 둘 것입니다 
 이 메모리에서 내 변수로 작업합니다. 
 문자 c는 대문자 H와 같습니다. 그러면 어떻게 될까요? 
 글쎄, 시스템은 나에게 1 바이트를 따로 둘 것입니다. 
 이 경우 4 번 바이트, 4 번 주소의 바이트, 
 그리고 그것은 저를 위해 문자 대문자 H를 저기에 저장할 것입니다. 
 그런 다음 int 제한 속도가 65와 같다면 
 나를 위해 4 바이트의 메모리를 따로 보관 해 두겠습니다. 
 이 4 바이트를 단일 단위로 취급합니다. 
 우리가 작업하는 것은 여기 정수입니다. 
 그리고 거기에 65를 저장할 것입니다. 
 >> 벌써 거짓말을하고 있습니다. 
 우리는 컴퓨터가 바이너리로 작동한다는 것을 알고 있기 때문입니다. 
 그들은 자본 H가 무엇인지 반드시 이해하지 못합니다. 
 또는 65가 무엇인지, 그들은 이진, 0과 1만을 이해합니다. 
 실제로 우리가 저장하고있는 것은 

Chinese: 
这是一个很小的内存块，这是20个字节的内存。 
前20个字节，因为我的地址位于底部
一直是0、1、2、3，依此类推，一直到19。 
当我声明变量并开始使用它们时， 
系统将为我留出一些空间
在我的记忆中与我的变量。 
所以我可以说，字符c等于大写字母H。这会发生什么？ 
那么系统将为我预留一个字节。 
在这种情况下，它选择了第四个字节，即地址四的字节， 
它将为我存储字母大写H。 
如果然后我说int速度限制等于65，那就是
将为我预留四个字节的内存。 
并将这四个字节视为一个单位
因为我们正在使用的是一个整数。 
它将在其中存储65。 
 >>现在我已经在告诉您一些谎言， 
是的，因为我们知道计算机以二进制形式工作。 
他们不一定了解什么是大写H 
或65是什么，他们只能理解二进制，零和一。 
所以实际上我们存储在那里

Arabic: 
 هنا جزء صغير جدا من الذاكرة ، هذا هو 20 بايت من الذاكرة. 
 أول 20 بايت لأن عنواني هناك في الأسفل 
 هي 0 ، 1 ، 2 ، 3 وهكذا على طول الطريق حتى 19. 
 وعندما أعلن المتغيرات وعندما أبدأ العمل معهم ، 
 سيقوم النظام بتخصيص بعض المساحة لي 
 في هذه الذاكرة للعمل مع متغيراتي. 
 لذا يمكنني القول أن الحرف c يساوي رأس المال H. وماذا سيحدث؟ 
 حسنًا ، النظام سيخصص لي بايت واحد. 
 في هذه الحالة اختار البايتة رقم أربعة ، البايت في العنوان الرابع ، 
 وستقوم بتخزين الحرف Capital H هناك من أجلي. 
 إذا قلت أن حد السرعة int يساوي 65 ، فهذا هو 
 ذاهب لتخصيص أربعة بايت من الذاكرة بالنسبة لي. 
 وستعامل هذه البايتات الأربعة كوحدة واحدة 
 لأن ما نعمل معه هو عدد صحيح هنا. 
 وسيخزن 65 هناك. 
 >> الآن أنا نوعًا ما أقول لك القليل من الكذب ، 
 صحيح ، لأننا نعلم أن أجهزة الكمبيوتر تعمل بشكل ثنائي. 
 إنهم لا يفهمون بالضرورة ما هو رأس المال H 
 أو ما هو 65 ، فهم فقط ثنائي وأصفار وأخرى. 
 وفي الواقع ما نقوم بتخزينه هناك 

Dutch: 
 Hier is een heel klein stukje geheugen, dit is 20 bytes geheugen. 
 De eerste 20 bytes omdat mijn adressen daar onderaan staan 
 zijn 0, 1, 2, 3, enzovoort tot 19. 
 En wanneer ik variabelen declareer en wanneer ik ermee begin te werken, 
 het systeem zal wat ruimte voor me vrijmaken 
 in dit geheugen om met mijn variabelen te werken. 
 Dus ik zou kunnen zeggen, char c is gelijk aan hoofdletter H. En wat gaat er gebeuren? 
 Nou, het systeem zal één byte voor mij opzij zetten. 
 In dit geval koos het byte nummer vier, de byte op adres vier, 
 en het zal de hoofdletter H voor mij erin opslaan. 
 Als ik dan zeg dat de maximumsnelheid voor int gelijk is aan 65, dan is dat zo 
 vier bytes geheugen opzij zetten voor mij. 
 En het gaat die vier bytes behandelen als één enkele eenheid 
 want waar we mee werken is hier een geheel getal. 
 En het zal daar 65 opslaan. 
 >> Nu vertel ik je al een beetje een leugen, 
 juist, omdat we weten dat computers binair werken. 
 Ze begrijpen niet noodzakelijkerwijs wat een hoofdletter H is 
 of wat een 65 is, ze begrijpen alleen binaire, nullen en enen. 
 En dus eigenlijk wat we daar opslaan 

Hindi: 
 यहाँ मेमोरी का एक बहुत छोटा हिस्सा है, यह मेमोरी का 20 बाइट्स है। 
 पहले 20 बाइट्स क्योंकि नीचे मेरे पते हैं 
 19 तक सभी तरह 0, 1, 2, 3, और इसी तरह हैं। 
 और जब मैं चर घोषित करता हूं और जब मैं उनके साथ काम करना शुरू करता हूं, 
 सिस्टम मेरे लिए कुछ जगह अलग करने जा रहा है 
 इस स्मृति में मेरे चर के साथ काम करने के लिए। 
 तो मैं कह सकता हूँ, चार सी राजधानी एच के बराबर है और क्या होने जा रहा है? 
 खैर सिस्टम मेरे लिए एक बाइट सेट करने जा रहा है। 
 इस मामले में इसने बाइट नंबर चार को चुना, पते चार पर बाइट, 
 और यह मेरे लिए पत्र कैपिटल एच को वहां स्टोर करने जा रहा है। 
 अगर मैं कहूं तो इंट स्पीड लिमिट 65 के बराबर है 
 मेरे लिए स्मृति के चार बाइट सेट करने के लिए जा रहा है। 
 और यह उन चार बाइट्स को एक इकाई के रूप में मानता है 
 क्योंकि जो हम साथ काम कर रहे हैं वह यहां पूर्णांक है। 
 और यह वहां 65 स्टोर करने जा रहा है। 
 >> अब पहले से ही मैं आपको झूठ का एक सा बता रहा हूँ, 
 सही है, क्योंकि हम जानते हैं कि कंप्यूटर बाइनरी में काम करते हैं। 
 वे जरूरी नहीं समझते कि एक पूंजी एच क्या है 
 या एक 65 क्या है, वे केवल बाइनरी, शून्य और लोगों को समझते हैं। 
 और इसलिए वास्तव में हम वहाँ क्या स्टोर कर रहे हैं 

Japanese: 
これは非常に小さなメモリのチャンクです。これは20バイトのメモリです。 
最初の20バイトはアドレスが一番下にあるため
 0、1、2、3など、19まで続きます。 
そして、変数を宣言するとき、そして変数での作業を始めるとき、 
システムがスペースを確保してくれます
このメモリで、変数を操作します。 
したがって、char cは大文字のHに等しいと言えるかもしれません。そして、どうなるでしょうか。 
さて、システムは私のために1バイトを確保します。 
この場合、バイト番号4、アドレス4のバイトを選択しました。 
大文字のHが格納されます。 
次に、intの速度制限が65に等しいと言うと、 
 4バイトのメモリを確保してください。 
そして、これらの4バイトを1つの単位として扱います。 
ここで扱うのは整数なので。 
そして、そこに65を格納します。 
 >>さて、もう少し嘘をついています。 
コンピュータがバイナリで動作することがわかっているためです。 
彼らは必ずしも首都Hが何であるかを理解していません
または65とは何か、彼らはバイナリ、0と1のみを理解します。 
そして実際にそこに保存しているのは

Turkish: 
 İşte çok küçük bir bellek yığını, bu 20 bayt bellek. 
 İlk 20 bayt çünkü adreslerim altta 
 0, 1, 2, 3, vb. ise 19'a kadar. 
 Değişkenleri beyan ettiğimde ve değişkenlerle çalışmaya başladığımda, 
 sistem benim için biraz yer ayıracak 
 bu bellekte değişkenlerimle çalışmak. 
 Yani diyebilirim ki, char c başkent H'ye eşit. Peki ne olacak? 
 Sistem benim için bir bayt ayıracak. 
 Bu durumda dördüncü bayt, dördüncü adresdeki bayt, 
 ve benim için büyük H harfi orada saklanacak. 
 Eğer int hız sınırının 65'e eşit olduğunu söylersem, 
 benim için dört bayt bellek ayıracak. 
 Ve bu dört bayta tek bir birim gibi davranacak 
 çünkü üzerinde çalıştığımız şey tamsayı. 
 Ve orada 65 depolayacak. 
 >> Şimdi sana biraz yalan söylüyorum, 
 doğru, çünkü bilgisayarların ikili olarak çalıştığını biliyoruz. 
 H sermayesinin ne olduğunu tam olarak anlamıyorlar 
 veya 65'in ne olduğunu, sadece ikili, sıfırları ve olanları anlıyorlar. 
 Ve aslında orada ne saklıyoruz 

Portuguese: 
 Aqui está um pedaço muito pequeno de memória, são 20 bytes de memória. 
 Os primeiros 20 bytes porque meus endereços lá na parte inferior 
 são 0, 1, 2, 3 e assim por diante até 19. 
 E quando declaro variáveis ​​e quando começo a trabalhar com elas, 
 o sistema vai reservar um espaço para mim 
 nesta memória para trabalhar com minhas variáveis. 
 Então, eu poderia dizer, char c igual a capital H. E o que vai acontecer? 
 Bem, o sistema vai me reservar um byte. 
 Nesse caso, ele escolheu o byte número quatro, o byte no endereço quatro, 
 e vai guardar a letra maiúscula H lá para mim. 
 Se eu disser que o limite de velocidade int é igual a 65, é 
 vai reservar quatro bytes de memória para mim. 
 E tratará esses quatro bytes como uma única unidade 
 porque estamos trabalhando com um número inteiro aqui. 
 E vai armazenar 65 lá. 
 >> Agora já estou meio que mentindo, 
 certo, porque sabemos que os computadores funcionam em binário. 
 Eles não entendem necessariamente o que é um H maiúsculo 
 ou o que é um 65, eles só entendem binário, zeros e uns. 
 E então, na verdade, o que estamos armazenando lá 

Chinese: 
這是一個很小的內存塊，這是20個字節的內存。 
前20個字節，因為我的地址位於底部
一直是0、1、2、3，依此類推，一直到19。 
當我聲明變量並開始使用它們時， 
系統將為我留出一些空間
在我的記憶中與我的變量一起工作。 
所以我可以說，字符c等於大寫字母H。這會發生什麼？ 
那麼系統將為我預留一個字節。 
在這種情況下，它選擇了第四個字節，即地址四的字節， 
它將為我存儲字母大寫H。 
如果然後我說int速度限制等於65，那就是
將為我預留四個字節的內存。 
並將這四個字節視為一個單位
因為我們正在使用的是一個整數。 
它將在其中存儲65。 
 >>現在我已經在告訴您一些謊言， 
是的，因為我們知道計算機以二進制形式工作。 
他們不一定了解什麼是大寫H 
或65是什麼，他們只能理解二進制，零和一。 
所以實際上我們存儲在那裡

Indonesian: 
 Berikut adalah sepotong memori yang sangat kecil, ini adalah 20 byte memori. 
 20 byte pertama karena alamat saya ada di bagian bawah 
 adalah 0, 1, 2, 3, dan seterusnya hingga 19. 
 Dan ketika saya mendeklarasikan variabel dan ketika saya mulai bekerja dengannya, 
 sistem akan menyisihkan beberapa ruang untuk saya 
 dalam memori ini untuk bekerja dengan variabel saya. 
 Jadi saya bisa mengatakan, char c sama dengan modal H. Dan apa yang akan terjadi? 
 Nah sistem akan menyisihkan untuk saya satu byte. 
 Dalam hal ini ia memilih byte nomor empat, byte pada alamat empat, 
 dan itu akan menyimpan huruf kapital H di sana untuk saya. 
 Jika saya katakan batas kecepatan int sama dengan 65, itu 
 akan menyisihkan empat byte memori untuk saya. 
 Dan itu akan memperlakukan empat byte sebagai satu unit 
 karena apa yang kami kerjakan adalah bilangan bulat di sini. 
 Dan itu akan menyimpan 65 di sana. 
 >> Sekarang saya sudah semacam mengatakan sedikit bohong, 
 benar, karena kita tahu bahwa komputer bekerja dalam biner. 
 Mereka tidak mengerti apa arti modal H 
 atau apa itu 65, mereka hanya mengerti biner, nol dan satu. 
 Dan sebenarnya apa yang kita simpan di sana 

English: 
Here's a very small chunk of memory, this is 20 bytes of memory.
The first 20 bytes because my addresses there at the bottom
are 0, 1, 2, 3, and so on all the way up to 19.
And when I declare variables and when I start to work with them,
the system is going to set aside some space for me
in this memory to work with my variables.
So I might say, char c equals capital H. And what's going to happen?
Well the system is going to set aside for me one byte.
In this case it chose byte number four, the byte at address four,
and it's going to store the letter capital H in there for me.
If I then say int speed limit equals 65, it's
going to set aside four bytes of memory for me.
And it's going to treat those four bytes as a single unit
because what we're working with is an integer here.
And it's going to store 65 in there.
>> Now already I'm kind of telling you a bit of a lie,
right, because we know that computers work in binary.
They don't understand necessarily what a capital H is
or what a 65 is, they only understand binary, zeros and ones.
And so actually what we're storing in there

Italian: 
 Ecco un piccolo pezzo di memoria, questo è 20 byte di memoria. 
 I primi 20 byte perché i miei indirizzi lì in fondo 
 sono 0, 1, 2, 3 e così via fino a 19. 
 E quando dichiaro variabili e quando inizio a lavorare con esse, 
 il sistema lascerà spazio per me 
 in questa memoria per lavorare con le mie variabili. 
 Quindi potrei dire, char c equivale alla capitale H. E cosa succederà? 
 Bene, il sistema metterà da parte per me un byte. 
 In questo caso ha scelto il byte numero quattro, il byte all'indirizzo quattro, 
 e memorizzerà la lettera maiuscola H per me. 
 Se poi dico che il limite di velocità int è uguale a 65, lo è 
 mettere da parte quattro byte di memoria per me. 
 E tratterà quei quattro byte come una singola unità 
 perché ciò con cui stiamo lavorando è un numero intero qui. 
 E ne memorizzerà 65 lì dentro. 
 >> Ora già ti sto dicendo un po 'di una bugia, 
 giusto, perché sappiamo che i computer funzionano in binario. 
 Non capiscono necessariamente cos'è una H maiuscola 
 o cos'è un 65, capiscono solo binari, zeri e quelli. 
 E così in realtà quello che stiamo memorizzando lì 

Dutch: 
 is niet de letter H en het cijfer 65, maar eerder de binaire representaties 
 daarvan, die er ongeveer zo uitzien. 
 En in het bijzonder in de context van de integer-variabele, 
 het spuugt het niet zomaar in, het behandelt het niet als een viertal 
 byte stuk noodzakelijkerwijs, het gaat eigenlijk 
 om het te behandelen als vier stukjes van één byte, die er ongeveer zo uit kunnen zien. 
 En zelfs dit is ook niet helemaal waar, 
 vanwege iets dat endianness wordt genoemd, wat we niet zijn 
 waar ik nu op in ga, maar als je nieuwsgierig bent naar, 
 je kunt lezen over kleine en grote duurzaamheid. 
 Maar omwille van dit argument, omwille van deze video, 
 laten we aannemen dat dit in feite is hoe het getal 65 zou zijn 
 op elk systeem in het geheugen worden weergegeven, 
 hoewel het niet helemaal waar is. 
 >> Maar laten we eigenlijk alle binaire bestanden volledig verwijderen, 
 en denk aan H en 65, het is een stuk eenvoudiger 
 om er zo over na te denken als mens. 
 Oké, dus het lijkt misschien ook een beetje willekeurig dat ik mijn systeem heb 
 gaf me geen bytes 5, 6, 7 en 8 om het gehele getal op te slaan. 
 Daar is ook een reden voor, waar we nu niet op ingaan, maar die volstaan 

Spanish: 
 no es la letra H y el número 65, sino las representaciones binarias 
 del mismo, que se parece un poco a esto. 
 Y en particular en el contexto de la variable entera, 
 no lo va a escupir, no lo va a tratar como un cuatro 
 byte necesariamente, en realidad va 
 para tratarlo como cuatro fragmentos de un byte, que podrían verse más o menos así. 
 E incluso esto tampoco es del todo cierto, 
 por algo llamado endianness, que no somos 
 voy a entrar ahora, pero si tienes curiosidad acerca de, 
 puedes leer sobre el endianness pequeño y grande. 
 Pero por el bien de este argumento, por el bien de este video, 
 supongamos que así es, de hecho, cómo sería el número 65 
 estar representado en la memoria en cada sistema, 
 aunque no es del todo cierto. 
 >> Pero en realidad, eliminemos todos los binarios por completo, 
 y solo piensa en H y 65, es mucho más fácil 
 pensar así como un ser humano. 
 Muy bien, entonces también parece un poco aleatorio que tengo mi sistema 
 no me dio los bytes 5, 6, 7 y 8 para almacenar el número entero. 
 También hay una razón para eso, en la que no entraremos en este momento, pero es suficiente 

Arabic: 
 ليس الحرف H والرقم 65 ، بل تمثيلات ثنائية 
 منها ، والتي تبدو شيء من هذا القبيل قليلا. 
 وبشكل خاص في سياق المتغير الصحيح ، 
 لن يبصقها فقط ، لن يعاملها كأحد أربعة 
 القطعة بايت بالضرورة ، انها في الواقع 
 للتعامل معها على أنها أربع قطع من بايت واحد ، والتي قد تبدو شيء من هذا القبيل. 
 وحتى هذا ليس صحيحًا تمامًا أيضًا ، 
 بسبب شيء يسمى endianness ، ونحن لسنا كذلك 
 سوف ندخل الآن ، ولكن إذا كنت مهتمًا ، 
 يمكنك أن تقرأ عن الاستمرارية الصغيرة والكبيرة. 
 ولكن من أجل هذه الحجة ، من أجل هذا الفيديو ، 
 دعنا نفترض أن هذا هو ، في الواقع ، كيف سيكون الرقم 65 
 يتم تمثيلها في الذاكرة على كل نظام ، 
 على الرغم من أن هذا ليس صحيحًا تمامًا. 
 >> ولكن دعونا في الواقع نتخلص من جميع الخيارات الثنائية تمامًا ، 
 وفكر فقط في H و 65 ، إنه أسهل بكثير 
 للتفكير في الأمر على هذا النحو كإنسان. 
 حسنًا ، لذلك يبدو أيضًا أنه عشوائي بعض الشيء - 
 لم يعطوني بايت 5 و 6 و 7 و 8 لتخزين العدد الصحيح. 
 هناك سبب لذلك أيضًا ، والذي لن ندخل فيه الآن ، ولكن يكفي 

Hindi: 
 अक्षर H और संख्या 65 नहीं है, बल्कि बाइनरी अभ्यावेदन है 
 तत्संबंधी, जो कुछ इस तरह दिखता है। 
 और विशेष रूप से पूर्णांक चर के संदर्भ में, 
 यह सिर्फ इसे थूकने वाला नहीं है, यह इसे एक चार मानने वाला नहीं है 
 बाइट चंक जरूरी, यह वास्तव में जा रहा है 
 इसे चार बाइट का हिस्सा माना जाता है, जो कुछ इस तरह दिख सकता है। 
 और यह भी पूरी तरह से सच नहीं है, 
 एंडियन नामक किसी चीज़ के कारण, जो हम नहीं हैं 
 अब में पाने के लिए जा रहा है, लेकिन अगर आप इसके बारे में उत्सुक हैं, 
 आप छोटे और बड़े धीरज पर पढ़ सकते हैं। 
 लेकिन इस तर्क के लिए, इस वीडियो के लिए, 
 चलो बस मान लेते हैं कि वास्तव में, संख्या 65 कैसे होगी 
 हर प्रणाली पर स्मृति में प्रतिनिधित्व किया, 
 हालांकि यह पूरी तरह सच नहीं है। 
 >> लेकिन चलो वास्तव में पूरी तरह से सभी बाइनरी से छुटकारा पाएं, 
 और बस एच और 65 के बारे में सोचें, यह बहुत आसान है 
 एक इंसान के रूप में इसके बारे में सोचना। 
 सब ठीक है, इसलिए यह भी लगता है कि शायद थोड़ा यादृच्छिक है कि मैं- मेरा सिस्टम 
 पूर्णांक को संग्रहीत करने के लिए मुझे बाइट्स 5, 6, 7 और 8 नहीं दिए। 
 इसके लिए एक कारण है, वह भी, जिसे हम अभी प्राप्त नहीं करेंगे, लेकिन पर्याप्त है 

Korean: 
 문자 H와 숫자 65가 아니라 이진 표현입니다. 
 이것과 비슷합니다. 
 특히 정수 변수의 맥락에서 
 그냥 침을 뱉지 않을 것이고, 그것을 4로 취급하지 않을 것입니다. 
 바이트 덩어리는 반드시 진행되고 있습니다. 
 이를 4 바이트의 1 바이트 청크로 처리합니다. 
 그리고 이것조차도 완전히 사실이 아닙니다. 
 우리가 아닌 엔디안 (endianness)이라는 무언가 때문에 
 지금 들어 가려고하지만 궁금한 점이 있다면 
 작고 큰 엔디안을 읽을 수 있습니다. 
 하지만이 주장을 위해서,이 비디오를 위해서 
 실제로 숫자 65가 어떻게 될지 가정 해 봅시다. 
 모든 시스템에서 메모리에 표현되고 
 완전히 사실은 아니지만. 
 >> 그러나 실제로 모든 바이너리를 완전히 제거합시다. 
 H와 65로 생각하면 훨씬 쉽습니다. 
 인간처럼 생각합니다. 
 좋아, 그래서 아마 내가 내 시스템을 약간 무작위로 보인다 
 정수를 저장하기 위해 바이트 5, 6, 7 및 8을주지 않았습니다. 
 그 이유도 있습니다. 지금 당장 들어가지는 않지만 충분합니다. 

Italian: 
 non è la lettera H e il numero 65, ma piuttosto le rappresentazioni binarie 
 di ciò, che assomigliano a qualcosa del genere. 
 E in particolare nel contesto della variabile intera, 
 non lo sputerà dentro, non lo tratterà come uno quattro 
 Chunk byte necessariamente, in realtà sta andando 
 per trattarlo come quattro blocchi di un byte, che potrebbero assomigliare a questo. 
 E anche questo non è del tutto vero, 
 a causa di qualcosa chiamato endianness, che non siamo 
 entrerò ora, ma se sei curioso di 
 puoi leggere su piccola e grande endianness. 
 Ma per il bene di questa discussione, per il bene di questo video, 
 supponiamo che sia, in effetti, come farebbe il numero 65 
 essere rappresentato in memoria su ogni sistema, 
 anche se non è del tutto vero. 
 >> Ma in realtà sbarazziamoci completamente di tutti i binari, 
 e pensa solo a H e 65, è molto più semplice 
 a pensarci così come un essere umano. 
 Va bene, quindi sembra anche un po 'casuale che io abbia il mio sistema 
 non mi ha dato byte 5, 6, 7 e 8 per memorizzare il numero intero. 
 C'è anche una ragione per questo, che non entreremo in questo momento, ma è sufficiente 

Turkish: 
 H harfi ve 65 sayısı değil, ikili gösterimlerdir 
 bunun gibi bir şeye benziyor. 
 Özellikle de tamsayı değişkeni bağlamında, 
 sadece tükürmekle kalmayacak, dört gibi davranmayacak 
 bayt yığın mutlaka, gidiyor 
 dört baytlık bir parça olarak ele alınabilir. 
 Ve bu bile tamamen doğru değil, 
 Endianness denilen bir şey yüzünden 
 şimdi gireceğim, ama merak ediyorsanız, 
 küçük ve büyük endianness hakkında okuyabilirsiniz. 
 Ancak bu tartışma uğruna, bu video uğruna, 
 farzedelim ki, 65 sayısı aslında 
 her sistemde hafızada temsil edilmek, 
 tamamen doğru olmasa da. 
 Ama aslında tüm ikili dosyalardan tamamen kurtuyalım, 
 ve sadece H ve 65 olarak düşünün, çok daha kolay 
 bunu bir insan olarak düşünmek. 
 Pekala, bu yüzden benim sistemim de 
 tamsayı saklamak için 5, 6, 7 ve 8 bayt vermedi. 
 Bunun için de şu anda girmeyeceğimiz bir sebep var, ama yeterli 

Chinese: 
不是字母H和数字65，而是二进制表示
其中，看起来有点像这样。 
特别是在整数变量的上下文中， 
它不会随便吐出来，也不会将其视为四分之一
字节块，实际上是
将其视为四个1字节的块，可能看起来像这样。 
甚至也不是完全正确的， 
因为所谓的字节序，我们不是
即将进入，但如果您对此感到好奇， 
您可以阅读小而大的字节序。 
但是为了这个论点，为了这个视频， 
让我们假设这实际上是65 
在每个系统的内存中都有代表
尽管并非完全如此。 
 >>但是，让我们实际上完全摆脱所有二进制文件， 
考虑一下H和65，就容易多了
像人类一样思考它。 
好的，所以我的系统似乎也有些随机
没有给我字节5、6、7和8来存储整数。 
这也是有原因的，我们现在不会讨论，但足够了

French: 
 n'est pas la lettre H et le nombre 65, mais plutôt les représentations binaires 
 celui-ci, qui ressemble à un petit quelque chose comme ça. 
 Et en particulier dans le contexte de la variable entière, 
 ça ne va pas juste le cracher, ça ne va pas le traiter comme un quatre 
 morceau d'octets nécessairement, ça va réellement 
 pour le traiter comme quatre morceaux d'un octet, qui pourraient ressembler à ceci. 
 Et même cela n'est pas entièrement vrai non plus, 
 à cause de quelque chose appelé endianité, ce que nous ne sommes pas 
 va entrer maintenant, mais si vous êtes curieux de savoir, 
 vous pouvez lire sur la petite et la grande endianité. 
 Mais pour le bien de cet argument, pour le bien de cette vidéo, 
 supposons simplement que c'est, en fait, comment le nombre 65 serait 
 être représenté en mémoire sur chaque système, 
 bien que ce ne soit pas tout à fait vrai. 
 >> Mais en fait, débarrassons-nous de tout binaire, 
 et pensez à H et 65, c'est beaucoup plus facile 
 d'y penser comme ça en tant qu'être humain. 
 Très bien, il semble donc peut-être un peu aléatoire que j'ai mon système 
 ne m'a pas donné les octets 5, 6, 7 et 8 pour stocker l'entier. 
 Il y a aussi une raison à cela, que nous n'entrerons pas dans le moment, mais il suffit 

English: 
is not the letter H and the number 65, but rather the binary representations
thereof, which look a little something like this.
And in particular in the context of the integer variable,
it's not going to just spit it into, it's not going to treat it as one four
byte chunk necessarily, it's actually going
to treat it as four one byte chunks, which might look something like this.
And even this isn't entirely true either,
because of something called an endianness, which we're not
going to get into now, but if you're curious about,
you can read up on little and big endianness.
But for the sake of this argument, for the sake of this video,
let's just assume that is, in fact, how the number 65 would
be represented in memory on every system,
although it's not entirely true.
>> But let's actually just get rid of all binary entirely,
and just think about as H and 65, it's a lot easier
to think about it like that as a human being.
All right, so it also seems maybe a little random that I've- my system
didn't give me bytes 5, 6, 7, and 8 to store the integer.
There's a reason for that, too, which we won't get into right now, but suffice

Portuguese: 
 não é a letra H e o número 65, mas as representações binárias 
 disso, que se parece um pouco com isso. 
 E, em particular, no contexto da variável inteira, 
 não vai cuspir, não vai tratá-lo como um quatro 
 byte chunk necessariamente, na verdade vai 
 tratá-lo como blocos de quatro bytes, que podem se parecer com isso. 
 E mesmo isso também não é totalmente verdade, 
 por causa de algo chamado endianness, que não estamos 
 vai entrar agora, mas se você estiver curioso, 
 você pode ler sobre pouca e grande dificuldade. 
 Mas por causa deste argumento, por causa deste vídeo, 
 vamos supor que é, de fato, como o número 65 seria 
 ser representado na memória em todos os sistemas, 
 embora não seja inteiramente verdade. 
 >> Mas vamos nos livrar de todos os binários inteiramente, 
 e pense em H e 65, é muito mais fácil 
 pensar assim como um ser humano. 
 Tudo bem, então também parece um pouco aleatório que eu ... meu sistema 
 não me forneceu bytes 5, 6, 7 e 8 para armazenar o número inteiro. 
 Há uma razão para isso também, na qual não entraremos agora, mas é suficiente 

Indonesian: 
 bukan huruf H dan angka 65, melainkan representasi biner 
 daripadanya, yang terlihat sedikit seperti ini. 
 Dan khususnya dalam konteks variabel integer, 
 itu tidak akan hanya meludahkannya, itu tidak akan memperlakukannya sebagai satu empat 
 chunk byte tentu, itu sebenarnya terjadi 
 untuk memperlakukannya sebagai empat potongan satu byte, yang mungkin terlihat seperti ini. 
 Dan bahkan ini juga tidak sepenuhnya benar, 
 karena sesuatu yang disebut endianness, yang bukan kita 
 akan masuk ke sekarang, tetapi jika Anda ingin tahu tentang, 
 Anda dapat membaca tentang endianness kecil dan besar. 
 Tetapi demi argumen ini, demi video ini, 
 mari kita asumsikan bahwa, pada kenyataannya, bagaimana angka 65 akan 
 diwakili dalam memori pada setiap sistem, 
 meskipun itu tidak sepenuhnya benar. 
 >> Tapi mari kita singkirkan semua biner sepenuhnya, 
 dan pikirkan saja H dan 65, itu jauh lebih mudah 
 untuk berpikir seperti itu sebagai manusia. 
 Baiklah, jadi mungkin juga sedikit acak bahwa saya sudah- sistem saya 
 tidak memberi saya byte 5, 6, 7, dan 8 untuk menyimpan integer. 
 Ada alasan untuk itu juga, yang tidak akan kita bahas sekarang, tapi cukuplah 

Russian: 
 это не буква H и число 65, а двоичные представления 
 из них, которые выглядят примерно так. 
 И, в частности, в контексте целочисленной переменной, 
 это не будет просто плевать на это, это не будет относиться к этому как к одному 
 байт кусок обязательно, это на самом деле происходит 
 рассматривать его как четыре однобайтовых фрагмента, которые могут выглядеть примерно так. 
 И даже это не совсем верно, 
 из-за того, что называется порядком байтов, который мы не 
 сейчас, но если вам интересно, 
 Вы можете прочитать о маленьких и больших порядках байтов. 
 Но ради этого аргумента, ради этого видео, 
 давайте просто предположим, что на самом деле, как число 65 будет 
 быть представленным в памяти в каждой системе, 
 хотя это не совсем так. 
 >> Но давайте просто избавимся от всего двоичного файла полностью, 
 и просто думать о том, как H и 65, это намного проще 
 думать об этом как о человеке. 
 Хорошо, так что это может показаться немного случайным, что я - моя система 
 не дал мне байтов 5, 6, 7 и 8 для хранения целого числа. 
 Для этого тоже есть причина, в которую мы не будем сейчас вдаваться, но достаточно 

Japanese: 
文字Hと数字65ではなく、バイナリ表現です
そのようなものに見えます
そして特に整数変数の文脈では
吐き出すだけではなく、1つ4つとして扱うつもりはありません
バイトチャンクは必然的に、実際に起こっています
これを4つの1バイトチャンクとして扱うには、次のようになります。 
そして、これも完全に真実ではありません、 
エンディアンネスと呼ばれるもののために
今から入りますが、もし興味があれば、 
リトルエンディアンとビッグエンディアンについて読むことができます。 
しかし、この議論のために、このビデオのために、 
それが実際には65という数字が
すべてのシステムのメモリに表示され、 
それは完全に真実ではありませんが。 
 >>しかし、実際にはすべてのバイナリを完全に削除してみましょう。 
 Hと65を考えると、ずっと簡単です。 
そのように人間として考えること。 
大丈夫、それで私が持っていることも多分少しランダムに見える-私のシステム
整数を格納するためのバイト5、6、7、および8を私に与えませんでした。 
その理由もあるので、今は説明しませんが、十分です

Modern Greek (1453-): 
 δεν είναι το γράμμα Η και ο αριθμός 65, αλλά οι δυαδικές αναπαραστάσεις 
 από αυτά, τα οποία φαίνονται λίγο κάτι τέτοιο. 
 Και ειδικότερα στο πλαίσιο της μεταβλητής ακέραιας, 
 δεν πρόκειται απλώς να το φτύσει, δεν πρόκειται να το αντιμετωπίσει ως ένα τέταρτο 
 byte κομμάτι αναγκαστικά, είναι πραγματικά πηγαίνει 
 για να το αντιμετωπίσουμε ως τέσσερα κομμάτια ένα byte, τα οποία θα μπορούσαν να φαίνονται κάτι τέτοιο. 
 Και ακόμη και αυτό δεν είναι εξ ολοκλήρου αλήθεια, 
 λόγω κάτι που ονομάζεται endianness, το οποίο δεν είμαστε 
 θα έρθουν τώρα, αλλά αν είστε περίεργοι, 
 μπορείτε να διαβάσετε το μικρό και μεγάλο endianness. 
 Αλλά για χάρη αυτού του επιχειρήματος, για χάρη αυτού του βίντεο, 
 ας υποθέσουμε ότι είναι, στην πραγματικότητα, ο αριθμός 65 
 να αναπαρίσταται στη μνήμη σε κάθε σύστημα, 
 αν και δεν είναι απολύτως αληθές. 
 >> Αλλά ας πραγματικά να απαλλαγούμε από όλα δυαδικά εξ ολοκλήρου, 
 και σκεφτείτε μόνο ως H και 65, είναι πολύ πιο εύκολο 
 να το σκεφτεί κανείς σαν άνθρωπος. 
 Εντάξει, έτσι φαίνεται ίσως και λίγο τυχαίο ότι έχω το δικό μου σύστημα 
 δεν μου έδωσε bytes 5, 6, 7 και 8 για να αποθηκεύσω τον ακέραιο αριθμό. 
 Υπάρχει και αυτός ένας λόγος για τον οποίο δεν θα μπορέσουμε να φτάσουμε τώρα, αλλά αρκεί 

German: 
 ist nicht der Buchstabe H und die Zahl 65, sondern die binären Darstellungen 
 davon, die ein bisschen so aussehen. 
 Und insbesondere im Zusammenhang mit der Ganzzahlvariablen 
 es wird nicht nur angespuckt, es wird nicht als eins vier behandelt 
 Byte Chunk unbedingt, es geht tatsächlich 
 um es als vier Ein-Byte-Blöcke zu behandeln, die ungefähr so ​​aussehen könnten. 
 Und auch das ist nicht ganz richtig, 
 wegen etwas, das man Endianness nennt, was wir nicht sind 
 Ich werde jetzt darauf eingehen, aber wenn Sie neugierig sind, 
 Sie können sich über kleine und große Endianness informieren. 
 Aber für dieses Argument, für dieses Video, 
 Nehmen wir einfach an, dass dies tatsächlich die Nummer 65 ist 
 auf jedem System im Speicher dargestellt werden, 
 obwohl es nicht ganz wahr ist. 
 >> Aber lassen Sie uns eigentlich alle Binärdateien ganz loswerden, 
 und denken Sie nur an H und 65, es ist viel einfacher 
 als Mensch so darüber nachzudenken. 
 Also gut, es scheint auch ein bisschen zufällig zu sein, dass ich mein System habe 
 Ich habe keine Bytes 5, 6, 7 und 8 zum Speichern der Ganzzahl erhalten. 
 Es gibt auch einen Grund dafür, auf den wir im Moment nicht eingehen werden, der aber ausreicht 

Chinese: 
不是字母H和數字65，而是二進製表示
其中，看起來有點像這樣。 
特別是在整數​​變量的上下文中， 
它不會隨便吐出來，也不會將其視為四分之一
字節塊，實際上是
將其視為四個1字節的塊，可能看起來像這樣。 
甚至也不是完全正確的， 
因為所謂的字節序，我們不是
即將進入，但如果您對此感到好奇， 
您可以閱讀小而大的字節序。 
但是為了這個論點，為了這個視頻， 
讓我們假設這實際上是65 
在每個系統的內存中都有代表
儘管並非完全如此。 
 >>但是，讓我們實際上完全擺脫所有二進製文件， 
考慮一下H和65，就容易多了
像人類一樣思考它。 
好的，所以我的系統似乎也有些隨機
沒有給我字節5、6、7和8來存儲整數。 
這也是有原因的，我們現在不會討論，但足夠了

Japanese: 
ここでコンピュータが何をしているか
おそらくそれは良い動きです。 
必ず背中合わせの記憶を与えないため。 
別の文字列を取得したい場合は、今から実行しますが、 
姓と呼び、ロイドを入れたい。 
 1文字に合わせる必要があります。 
 1文字、1バイトのメモリが必要になります。 
だから、もし私がロイドをこのように私の配列に入れることができたら、私は行くのはかなりいいですよね？ 
何が欠けていますか？ 
 >> Cで使用するすべての文字列は、バックスラッシュゼロで終了することに注意してください。 
ここでも省略できません。 
それを保持するために1バイトのメモリを確保する必要があるので、 
文字列がいつ終了したかを知ってください。 
再びこの方法の配置は
メモリに表示されるのは少しランダムかもしれませんが、 
しかし、実際にはほとんどのシステムがどのように設計されているかです。 
再び理由により、それらを4の倍数で並べる
今は入り込む必要はありません。 
しかし、これは、この3行のコードの後、 
これはメモリがどのように見えるかです。 
データを保持するためにメモリロケーション4、8、12が必要な場合、 

Korean: 
 컴퓨터가 여기서하는 일 
 아마도 그 부분에서 좋은 움직임 일 것입니다. 
 필연적으로 연속적인 기억을주지 않습니다. 
 다른 문자열을 얻으려면 지금해야하지만 
 성이라고 부르고 로이드를 넣고 싶습니다. 
 한 글자 만 맞으면됩니다. 각 글자는 
 하나의 문자, 1 바이트의 메모리가 필요합니다. 
 Lloyd를 이와 같이 배열에 넣을 수 있다면 정말 잘가요? 
 무엇이 빠졌습니까? 
 >> C에서 작업하는 모든 문자열은 백 슬래시 0으로 끝납니다. 
 그리고 여기서도 생략 할 수 없습니다. 
 이를 유지하려면 1 바이트의 메모리를 따로 보관해야합니다. 
 우리의 줄이 언제 끝났는지 알고 있습니다. 
 다시 한번 말하지만 이런 방식으로 
 메모리에 나타나는 것은 약간 무작위 일 수 있습니다. 
 그러나 실제로 대부분의 시스템이 설계된 방식입니다. 
 다시 사유로 4의 배수로 정렬하려면 
 지금 당장 시작할 필요는 없습니다 
 그러나 이것은이 세 줄의 코드 후에 
 이것이 메모리의 모습입니다. 
 데이터를 저장하기 위해 메모리 위치 4, 8 및 12가 필요한 경우, 

Italian: 
 per dire che cosa sta facendo il computer qui 
 è probabilmente una buona mossa da parte sua. 
 Per non darmi memoria che è necessariamente schiena contro schiena. 
 Anche se lo farà ora se voglio ottenere un'altra stringa, 
 chiamato cognome, e voglio inserire Lloyd. 
 Ho bisogno di inserire un personaggio, ogni lettera di quello 
 richiederà un carattere, un byte di memoria. 
 Quindi, se potessi mettere Lloyd nel mio array in questo modo, sono abbastanza bravo da fare, giusto? 
 Cosa manca? 
 >> Ricorda che ogni stringa con cui lavoriamo in C termina con una barra rovesciata zero, 
 e non possiamo ometterlo neanche qui. 
 Dobbiamo mettere da parte un byte di memoria per mantenerlo così anche noi 
 sapere quando è finita la nostra stringa. 
 Quindi di nuovo questa disposizione del modo in cui le cose 
 apparire in memoria potrebbe essere un po 'casuale, 
 ma in realtà è come sono progettati la maggior parte dei sistemi. 
 Per allinearli su multipli di quattro, per ragioni ancora 
 che non abbiamo bisogno di entrare in questo momento. 
 Ma questo, basti dire che dopo queste tre righe di codice, 
 questo è come potrebbe apparire la memoria. 
 Se ho bisogno di posizioni di memoria 4, 8 e 12 per conservare i miei dati, 

Portuguese: 
 dizer que o que o computador está fazendo aqui 
 provavelmente é uma boa jogada da parte dele. 
 Para não me dar memória, isso é necessariamente repetitivo. 
 Embora faça agora, se eu quiser outra string, 
 chamado sobrenome, e eu quero colocar o Lloyd lá. 
 Vou precisar ajustar um caractere, cada letra desse 
 vai exigir um caractere, um byte de memória. 
 Então, se eu pudesse colocar Lloyd na minha matriz assim, eu estou muito bem, certo? 
 O que está a faltar? 
 >> Lembre-se de que toda string com a qual trabalhamos em C termina com barra invertida zero, 
 e também não podemos omitir isso aqui. 
 Precisamos reservar um byte de memória para manter isso, para que 
 saber quando nossa string terminou. 
 Então, novamente, esse arranjo da maneira como as coisas 
 aparecer na memória pode ser um pouco aleatório, 
 mas na verdade é como a maioria dos sistemas é projetada. 
 Para alinhá-los em múltiplos de quatro, por razões novamente 
 que não precisamos entrar agora. 
 Mas isso basta dizer que, após essas três linhas de código, 
 é assim que a memória pode parecer. 
 Se eu precisar dos locais de memória 4, 8 e 12 para armazenar meus dados, 

Arabic: 
 أن نقول أن ما يفعله الكمبيوتر هنا 
 ربما تكون خطوة جيدة من جانبها. 
 لا تعطيني الذاكرة التي هي بالضرورة متتالية. 
 على الرغم من أنها ستفعل ذلك الآن إذا كنت أريد الحصول على سلسلة أخرى ، 
 يسمى اللقب ، وأريد أن أضع لويد هناك. 
 سأحتاج إلى احتواء حرف واحد ، كل حرف من ذلك 
 سيتطلب حرف واحد ، بايت واحد من الذاكرة. 
 لذا ، إذا كان بإمكاني وضع Lloyd في مجموعتي بهذه الطريقة ، فأنا جيد جدًا في الذهاب ، أليس كذلك؟ 
 ما المفقود؟ 
 >> تذكر أن كل سلسلة نعمل معها في C تنتهي بشرطة مائلة عكسية صفر ، 
 ولا يمكننا حذف ذلك هنا أيضًا. 
 نحن بحاجة إلى تخصيص بايت واحد من الذاكرة للحفاظ على ذلك حتى نحن 
 اعرف متى انتهت خيطتنا. 
 لذا مرة أخرى هذا الترتيب للطريقة الأشياء 
 قد تظهر في الذاكرة بشكل عشوائي قليلاً ، 
 ولكن في الواقع كيف يتم تصميم معظم الأنظمة. 
 لترتيبها على مضاعفات أربعة ، لأسباب مرة أخرى 
 التي لا نحتاج إلى الدخول إليها الآن. 
 ولكن هذا يكفي أن نقول أنه بعد هذه الأسطر الثلاثة من التعليمات البرمجية ، 
 هذا ما قد تبدو عليه الذاكرة. 
 إذا كنت بحاجة إلى مواقع الذاكرة 4 و 8 و 12 للاحتفاظ ببياناتي ، 

Chinese: 
说计算机在这里做什么
这可能是一个好举动。 
为了不给我记忆，必须背对背。 
尽管如果我想获取另一个字符串，现在就要做， 
叫姓，我想把劳埃德放在那里。 
我需要适合一个字符，每个字母是
将需要一个字符，一个字节的内存。 
因此，如果我可以像这样将劳埃德（Lloyd）放入我的阵列中，那我就很好了，对吗？ 
少了什么东西？ 
 >>请记住，我们在C中使用的每个字符串都以反斜杠零结尾， 
我们也不能在这里忽略它。 
我们需要预留一个字节的内存来保存它
知道我们的字符串何时结束。 
再次，这种事情的安排
出现在内存中可能有点随机， 
但这实际上是大多数系统的设计方式。 
再次将它们排列在四个的倍数上
我们不需要现在就进入。 
但这足以说在这三行代码之后， 
这就是内存的样子。 
如果我需要内存位置4、8和12来保存数据， 

Russian: 
 это сказать, что то, что компьютер делает здесь 
 вероятно, хороший ход с его стороны. 
 Чтобы не дать мне память, это обязательно спина к спине. 
 Хотя он собирается сделать это сейчас, если я хочу получить другую строку, 
 назвал фамилию, и я хочу положить туда Ллойда. 
 Мне нужно будет соответствовать один символ, каждая буква которого 
 потребуется один символ, один байт памяти. 
 Так что, если бы я мог поместить Ллойда в свой массив таким образом, я бы очень хорошо пошел, верно? 
 Чего не хватает? 
 >> Помните, что каждая строка, с которой мы работаем в C, заканчивается нулевой обратной косой чертой, 
 и мы не можем опустить это здесь. 
 Нам нужно выделить один байт памяти, чтобы держать его, чтобы мы 
 знать, когда наша строка закончилась. 
 Итак, снова это расположение вещей 
 появиться в памяти может быть немного случайным, 
 но на самом деле так устроено большинство систем. 
 Чтобы выстроить их в ряды по четыре, снова по причинам 
 что нам не нужно сейчас углубляться. 
 Но этого достаточно, чтобы сказать, что после этих трех строк кода 
 это то, как может выглядеть память. 
 Если мне нужны ячейки памяти 4, 8 и 12 для хранения моих данных, 

Dutch: 
 om te zeggen wat de computer hier doet 
 is waarschijnlijk een goede zet van zijn kant. 
 Om me geen geheugen te geven, dat is noodzakelijkerwijs rug aan rug. 
 Hoewel het het nu gaat doen als ik nog een snaar wil, 
 achternaam genoemd, en ik wil Lloyd erin stoppen. 
 Ik moet één teken passen, elke letter daarvan 
 een karakter, een byte geheugen nodig hebben. 
 Dus als ik Lloyd zo in mijn array zou kunnen stoppen, ben ik redelijk goed om te gaan, toch? 
 Wat ontbreekt er? 
 >> Onthoud dat elke string waarmee we werken in C eindigt met backslash nul, 
 en dat kunnen we hier ook niet weglaten. 
 We moeten één byte geheugen opzij zetten om dat vast te houden, dus we 
 weten wanneer onze string is afgelopen. 
 Dus nogmaals deze opstelling van de manier waarop dingen 
 verschijnen in het geheugen kan een beetje willekeurig zijn, 
 maar het is eigenlijk hoe de meeste systemen zijn ontworpen. 
 Om ze om meerdere redenen op een veelvoud van vier te plaatsen 
 waar we nu niet op hoeven in te gaan. 
 Maar dit, zo volstaat het om te zeggen dat na deze drie regels code, 
 zo zou het geheugen eruit kunnen zien. 
 Als ik geheugenlocaties 4, 8 en 12 nodig heb om mijn gegevens te bewaren, 

German: 
 es zu sagen, was der Computer hier tut 
 ist wahrscheinlich ein guter Schachzug. 
 Um mir keine Erinnerung zu geben, die notwendigerweise Rücken an Rücken ist. 
 Obwohl es jetzt so sein wird, wenn ich einen anderen String bekommen möchte, 
 genannt Nachname, und ich möchte Lloyd dort setzen. 
 Ich muss ein Zeichen passen, jeder Buchstabe davon 
 benötigt ein Zeichen, ein Byte Speicher. 
 Wenn ich Lloyd so in mein Array aufnehmen könnte, wäre ich ziemlich gut, oder? 
 Was fehlt? 
 >> Denken Sie daran, dass jeder String, mit dem wir in C arbeiten, mit Backslash Null endet. 
 und das können wir auch hier nicht auslassen. 
 Wir müssen ein Byte Speicher beiseite legen, um das zu halten, damit wir 
 wissen, wann unsere Zeichenfolge beendet ist. 
 Also nochmal diese Anordnung der Art und Weise der Dinge 
 im Gedächtnis erscheinen könnte ein wenig zufällig sein, 
 Aber genau so sind die meisten Systeme aufgebaut. 
 Aus Gründen wieder auf Vielfache von vier auszurichten 
 dass wir jetzt nicht darauf eingehen müssen. 
 Aber das, so genügt es zu sagen, dass nach diesen drei Codezeilen, 
 So könnte Erinnerung aussehen. 
 Wenn ich die Speicherplätze 4, 8 und 12 benötige, um meine Daten zu speichern, 

Turkish: 
 bilgisayarın burada ne yaptığını söylemek 
 muhtemelen kendi adına iyi bir hamle. 
 Bana mutlaka arka arkaya anı vermemek. 
 Başka bir dize almak istiyorsam şimdi yapacak olsa da, 
 soyadı diye sordum ve Lloyd'u oraya koymak istiyorum. 
 Bir karaktere uymam gerekecek, bunun her harfi 
 bir karakter, bir bayt bellek gerektirecek. 
 Eğer Lloyd'u böyle dizime koyabilirsem, gitmek için oldukça iyiyim, değil mi? 
 Ne kayıp? 
 >> C ile birlikte çalıştığımız her dizenin ters eğik çizgi sıfırıyla bittiğini, 
 ve bunu burada da atlayamayız. 
 Bunu tutmak için bir bayt bellek ayırmamız gerekiyor. 
 dizimizin ne zaman sona erdiğini bilmek. 
 Yani yine bu şekilde düzenleme 
 bellekte görünmek biraz rastgele olabilir, 
 ama aslında çoğu sistem bu şekilde tasarlanır. 
 Tekrar nedenlerden ötürü onları dörtlüün katlarına dizmek için 
 şu anda içine girmemiz gerekmiyor. 
 Ama bu, bu üç kod satırından sonra, 
 hafıza böyle görünebilir. 
 Verilerimi tutmak için 4, 8 ve 12 numaralı bellek konumlarına ihtiyacım olursa, 

Chinese: 
說計算機在這裡做什麼
這可能是一個好舉動。 
為了不給我記憶，必須背對背。 
儘管如果我想獲取另一個字符串，現在就要做， 
叫姓，我想把勞埃德放在那裡。 
我需要適合一個字符，每個字母是
將需要一個字符，一個字節的內存。 
因此，如果我可以像這樣將勞埃德（Lloyd）放入我的陣列中，我就很好了，對吧？ 
少了什麼東西？ 
 >>請記住，我們在C中使用的每個字符串都以反斜杠零結尾， 
我們也不能在這裡忽略它。 
我們需要預留一個字節的內存來保存它
知道我們的字符串何時結束。 
再次，這種事情的安排
出現在內存中可能有點隨機， 
但這實際上是大多數係統的設計方式。 
再次將它們排列在四個的倍數上
我們不需要現在就進入。 
但這足以說在這三行代碼之後， 
這就是內存的樣子。 
如果我需要內存位置4、8和12來保存數據， 

Modern Greek (1453-): 
 να πει ότι αυτό που κάνει ο υπολογιστής εδώ 
 είναι πιθανώς μια καλή κίνηση από την πλευρά του. 
 Για να μην μου δώσετε μνήμη που είναι απαραίτητα πίσω στην πλάτη. 
 Παρόλο που πρόκειται να το κάνω τώρα αν θέλω να πάρω μια άλλη σειρά, 
 ονομάζεται επώνυμο και θέλω να βάλω τον Lloyd εκεί. 
 Θα χρειαστεί να χωρέσω έναν χαρακτήρα, κάθε γράμμα αυτού 
 που απαιτούν ένα χαρακτήρα, ένα byte μνήμης. 
 Έτσι, αν μπορούσα να βάλω τον Lloyd σε αυτή τη σειρά μου, είμαι πολύ καλός για να πάω, έτσι; 
 Τι λείπει? 
 >> Να θυμάστε ότι κάθε συμβολοσειρά που δουλεύουμε με το C τελειώνει με αντίστροφη κάθετο, 
 και δεν μπορούμε να το παραλείψουμε εδώ. 
 Πρέπει να παραμερίσουμε ένα byte μνήμης για να το κρατήσουμε έτσι 
 ξέρει πότε έληξε η συμβολοσειρά μας. 
 Έτσι και πάλι αυτή η ρύθμιση του τρόπου πράγματα 
 εμφανίζονται στη μνήμη μπορεί να είναι λίγο τυχαία, 
 αλλά στην πραγματικότητα είναι ο τρόπος με τον οποίο σχεδιάζονται τα περισσότερα συστήματα. 
 Για να τα κατατάξουμε σε πολλαπλάσια των τεσσάρων, για λόγους και πάλι 
 ότι δεν χρειάζεται να μπεις τώρα. 
 Αλλά αυτό, αρκεί να πούμε ότι μετά από αυτές τις τρεις γραμμές κώδικα, 
 αυτή είναι η μνήμη που μπορεί να μοιάζει. 
 Εάν χρειάζομαι τοποθεσίες μνήμης 4, 8 και 12 για να κρατήσω τα δεδομένα μου, 

Indonesian: 
 untuk mengatakan bahwa apa yang dilakukan komputer di sini 
 mungkin merupakan langkah yang baik pada bagiannya. 
 Untuk tidak memberi saya memori itu harus kembali ke belakang. 
 Meskipun akan melakukannya sekarang jika saya ingin mendapatkan string lain, 
 disebut nama keluarga, dan saya ingin menempatkan Lloyd di sana. 
 Saya perlu mencocokkan satu karakter, setiap hurufnya 
 akan membutuhkan satu karakter, satu byte memori. 
 Jadi jika saya bisa memasukkan Lloyd ke dalam array saya seperti ini, saya cukup bagus, bukan? 
 Apa yang hilang 
 >> Ingat bahwa setiap string yang kita gunakan di C diakhiri dengan garis miring terbalik nol, 
 dan kita juga tidak bisa menghilangkannya di sini. 
 Kita perlu menyisihkan satu byte memori untuk menahannya jadi kita 
 tahu kapan string kami telah berakhir. 
 Jadi sekali lagi ini pengaturan cara segalanya 
 muncul di memori mungkin sedikit acak, 
 tetapi sebenarnya cara sebagian besar sistem dirancang. 
 Untuk mengaturnya di kelipatan empat, karena alasan lagi 
 bahwa kita tidak perlu masuk sekarang. 
 Tapi ini, jadi sudah cukup untuk mengatakan bahwa setelah tiga baris kode ini, 
 seperti inilah ingatannya. 
 Jika saya membutuhkan lokasi memori 4, 8, dan 12 untuk menyimpan data saya, 

French: 
 pour dire que ce que l'ordinateur fait ici 
 est probablement une bonne décision de sa part. 
 Pour ne pas me donner de mémoire c'est forcément dos à dos. 
 Bien que ça va le faire maintenant si je veux obtenir une autre chaîne, 
 appelé nom de famille, et je veux mettre Lloyd là-dedans. 
 Je vais devoir adapter un caractère, chaque lettre de c'est 
 va exiger un caractère, un octet de mémoire. 
 Donc, si je pouvais mettre Lloyd dans mon tableau comme ça, je suis assez bon pour aller, non? 
 Qu'est-ce qui manque? 
 >> N'oubliez pas que chaque chaîne avec laquelle nous travaillons en C se termine par une barre oblique inverse, 
 et nous ne pouvons pas omettre cela ici non plus. 
 Nous devons mettre de côté un octet de mémoire pour que nous puissions 
 savoir quand notre chaîne est terminée. 
 Encore une fois, cet arrangement de la façon dont les choses 
 apparaître en mémoire peut être un peu aléatoire, 
 mais c'est en fait la façon dont la plupart des systèmes sont conçus. 
 Pour les aligner sur des multiples de quatre, pour des raisons encore 
 que nous n'avons pas besoin d'entrer en ce moment. 
 Mais cela, il suffit donc de dire qu'après ces trois lignes de code, 
 voici à quoi pourrait ressembler la mémoire. 
 Si j'ai besoin des emplacements de mémoire 4, 8 et 12 pour conserver mes données, 

English: 
it to say that what the computer is doing here
is probably a good move on its part.
To not give me memory that's necessarily back to back.
Although it's going to do it now if I want to get another string,
called surname, and I want to put Lloyd in there.
I'm going to need to fit one character, each letter of that's
going to require one character, one byte of memory.
So if I could put Lloyd into my array like this I'm pretty good to go, right?
What's missing?
>> Remember that every string we work with in C ends with backslash zero,
and we can't omit that here, either.
We need to set aside one byte of memory to hold that so we
know when our string has ended.
So again this arrangement of the way things
appear in memory might be a little random,
but it actually is how most systems are designed.
To line them up on multiples of four, for reasons again
that we don't need to get into right now.
But this, so suffice it to say that after these three lines of code,
this is what memory might look like.
If I need memory locations 4, 8, and 12 to hold my data,

Spanish: 
 es decir que lo que hace la computadora aquí 
 Es probablemente un buen movimiento de su parte. 
 Para no darme memoria, eso es necesariamente espalda con espalda. 
 Aunque va a hacerlo ahora si quiero obtener otra cadena, 
 llamado apellido, y quiero poner a Lloyd allí. 
 Voy a necesitar un carácter, cada letra de eso 
 va a requerir un caracter, un byte de memoria. 
 Entonces, si pudiera poner a Lloyd en mi matriz de esta manera, sería bastante bueno, ¿verdad? 
 Lo que falta 
 >> Recuerde que cada cadena con la que trabajamos en C termina con una barra diagonal inversa cero, 
 y tampoco podemos omitir eso aquí. 
 Necesitamos reservar un byte de memoria para mantener eso, así que 
 saber cuando nuestra cadena ha terminado. 
 Así que de nuevo este arreglo de la forma en que las cosas 
 aparecer en la memoria puede ser un poco aleatorio, 
 pero en realidad es cómo están diseñados la mayoría de los sistemas. 
 Para alinearlos en múltiplos de cuatro, por razones nuevamente 
 que no necesitamos entrar ahora mismo. 
 Pero esto, es suficiente decir que después de estas tres líneas de código, 
 así es como se vería la memoria. 
 Si necesito las ubicaciones de memoria 4, 8 y 12 para guardar mis datos, 

Hindi: 
 यह कहना है कि कंप्यूटर यहाँ क्या कर रहा है 
 शायद अपनी ओर से एक अच्छी चाल है। 
 मुझे स्मृति नहीं देने के लिए जरूरी है कि बैक टू बैक। 
 हालाँकि यह अब होने जा रहा है अगर मैं एक और स्ट्रिंग प्राप्त करना चाहता हूँ, 
 उपनाम कहा जाता है, और मैं लॉयड को वहां लाना चाहता हूं। 
 मुझे एक पात्र फिट करने की आवश्यकता है, उसके प्रत्येक अक्षर को 
 एक चरित्र, स्मृति की एक बाइट की आवश्यकता होती है। 
 तो अगर मैं लॉयड को अपने एरे में डाल सकता हूं तो इस तरह से मैं जाने के लिए बहुत अच्छा हूं, है ना? 
 क्या कमी है? 
 >> याद रखें कि सी में हम जिस भी स्ट्रिंग के साथ काम करते हैं वह बैकस्लैश शून्य के साथ समाप्त होती है, 
 और हम यहां या तो छोड़ नहीं सकते। 
 हमें मेमोरी के एक बाइट को अलग रखने की आवश्यकता है ताकि हम ऐसा कर सकें 
 पता है कि हमारी स्ट्रिंग कब समाप्त हुई। 
 तो फिर से इस तरह से चीजों की व्यवस्था 
 स्मृति में प्रकट थोड़ा यादृच्छिक हो सकता है, 
 लेकिन यह वास्तव में है कि अधिकांश सिस्टम कैसे डिज़ाइन किए जाते हैं। 
 फिर से कारणों के लिए, उन्हें चार के गुणकों पर लाइन करने के लिए 
 कि हमें अभी इसमें उतरने की आवश्यकता नहीं है। 
 लेकिन यह, यह कहने के लिए पर्याप्त है कि कोड की इन तीन पंक्तियों के बाद, 
 यह वही है जो स्मृति की तरह लग सकता है। 
 यदि मुझे अपना डेटा रखने के लिए मेमोरी लोकेशन 4, 8 और 12 की आवश्यकता है, 

Turkish: 
 hafızam böyle görünebilir. 
 >> Ve burada özellikle bilgiç olun, 
 biz genellikle bellek adreslerinden bahsediyoruz 
 bunu onaltılık gösterimler kullanarak yapın. 
 Öyleyse neden bunların hepsini ondalıktan onaltılı gösterime dönüştürmüyoruz 
 sadece hafızayı böyle ifade ettiğimiz için. 
 Yani 0 ile 19 olmak yerine, elimizde sıfır var 
 x sıfırdan sıfırya x1 üç. 
 Bunlar sahip olduğumuz 20 bayt bellek veya bu görüntüde bakıyoruz 
 tam burada. 
 >> Tüm bunlar söyleniyor, bir anlığına hafızadan uzaklaşalım 
 ve göstericilere geri dönelim. 
 İşte hatırlanması gereken en önemli şey 
 işaretçilerle çalışmaya başladık. 
 İşaretçi bir adres olmaktan başka bir şey değildir. 
 Tekrar söyleyeceğim çünkü bu önemli, 
 işaretçi bir adres olmaktan başka bir şey değildir. 
 İşaretçiler, bellekteki değişkenlerin yaşadığı konumlara yönelik adreslerdir. 
 Onlarla çalışmanın umarım biraz daha kolay hale geldiğini bilmek. 
 Yapmaktan hoşlandığım bir diğer şey de 
 çeşitli kod satırlarında olanları görsel olarak temsil eden diyagramların listesi. 

Spanish: 
 así es como se vería mi memoria. 
 >> Y sé particularmente pedante aquí, cuando 
 estamos hablando de direcciones de memoria que solemos 
 hazlo usando anotaciones hexadecimales. 
 Entonces, ¿por qué no convertimos todo esto de notación decimal a hexadecimal? 
 solo porque generalmente nos referimos a la memoria. 
 Entonces, en lugar de ser de 0 a 19, lo que tenemos es cero 
 x cero a cero x1 tres. 
 Esos son los 20 bytes de memoria que tenemos o que estamos viendo en esta imagen. 
 aquí mismo. 
 >> Entonces, dicho todo esto, alejémonos de la memoria por un segundo 
 y de vuelta a los punteros. 
 Aquí está lo más importante para recordar. 
 a medida que comenzamos a trabajar con punteros. 
 Un puntero no es más que una dirección. 
 Lo diré nuevamente porque es tan importante, 
 un puntero no es más que una dirección. 
 Los punteros son direcciones a ubicaciones en la memoria donde viven las variables. 
 Sabiendo que es un poco más fácil trabajar con ellos. 
 Otra cosa que me gusta hacer es ordenar 
 de diagramas que representan visualmente lo que sucede con varias líneas de código. 

Korean: 
 이것은 내 기억처럼 보일 것입니다. 
 >> 때 특히 여기에 pedantic 
 우리는 일반적으로 메모리 주소에 대해 이야기하고 있습니다. 
 16 진 표기법을 사용하십시오. 
 왜이 모든 것을 십진법에서 16 진법으로 변환하지 않겠습니까? 
 그것이 일반적으로 우리가 메모리를 참조하는 방식이기 때문입니다. 
 0에서 19가 아닌 0은 0입니다. 
 x 0에서 0 x1 3까지. 
 그것들은 우리가 가지고 있거나이 이미지에서보고있는 20 바이트의 메모리입니다 
 바로 여기에. 
 >> 그 모든 말이 기억에서 잠시 벗어나자 
 포인터로 돌아갑니다. 
 기억해야 할 가장 중요한 것은 다음과 같습니다. 
 포인터로 작업하기 시작합니다. 
 포인터는 주소에 지나지 않습니다. 
 그것이 중요하기 때문에 다시 말할 것입니다. 
 포인터는 주소에 지나지 않습니다. 
 포인터는 변수가있는 메모리의 위치에 대한 주소입니다. 
 그들과 함께 작업하기가 조금 더 쉬워진다는 것을 알고 있습니다. 
 내가 좋아하는 또 다른 것은 정렬하는 것입니다. 
 다양한 코드 라인에서 일어나는 일을 시각적으로 나타내는 다이어그램. 

Russian: 
 вот так может выглядеть моя память. 
 >> И просто будь особенно педантичным здесь, когда 
 мы говорим об адресах памяти, которые мы обычно 
 сделать это с помощью шестнадцатеричных обозначений. 
 Так почему бы нам не преобразовать все это из десятичной в шестнадцатеричную запись 
 просто потому, что мы обычно так называем память. 
 Таким образом, вместо того, чтобы быть от 0 до 19, у нас есть ноль 
 х ноль через ноль х1 три. 
 Это те 20 байтов памяти, которые у нас есть или мы смотрим на это изображение 
 Прямо здесь. 
 >> Так что все это, как говорится, давайте на секунду отступим от памяти 
 и вернемся к указателям. 
 Вот самое важное, что нужно запомнить 
 как мы начинаем работать с указателями. 
 Указатель - это не более чем адрес. 
 Я скажу это снова, потому что это так важно, 
 указатель - не более чем адрес. 
 Указатели - это адреса в ячейках памяти, где живут переменные. 
 Зная, что, надеюсь, с ними станет немного легче работать. 
 Еще одна вещь, которую я люблю делать, это иметь сортировку 
 диаграмм, визуально представляющих, что происходит с различными строками кода. 

Japanese: 
これが私の記憶のようです。 
 >>そして、特にここでは、特に注意深く
私たちは通常私たちがメモリアドレスについて話している
 16進数表記を使用してください。 
では、これらすべてを10進表記から16進表記に変換してみませんか
それが一般的にメモリを参照する方法だからです。 
したがって、0から19ではなく、ゼロです。 
 xゼロからゼロx1 3まで。 
これらは、私たちが持っているか、この画像で見ている20バイトのメモリです
ここです
 >>以上のことをすべて説明したので、少しメモリから離れましょう。 
ポインタに戻ります。 
ここで覚えておくべき最も重要なことです
ポインタの操作を開始すると、 
ポインタはアドレスにすぎません。 
それはとても重要なのでもう一度言います
ポインタはアドレスにすぎません。 
ポインタは、変数が存在するメモリ内の場所へのアドレスです。 
うまくいけば、彼らと仕事をするのが少し楽になることを知っています。 
私がやりたいもう一つは、並べ替えをすることです
コードのさまざまな行で何が起こっているのかを視覚的に表す図。 

Portuguese: 
 é assim que minha memória pode parecer. 
 >> E seja particularmente pedante aqui, quando 
 estamos falando de endereços de memória que geralmente 
 faça isso usando notações hexadecimais. 
 Então, por que não convertemos tudo isso da notação decimal para a hexadecimal 
 só porque é geralmente assim que nos referimos à memória. 
 Então, em vez de ser de 0 a 19, o que temos é zero 
 x zero a zero x1 três. 
 Esses são os 20 bytes de memória que temos ou estamos vendo nesta imagem 
 bem aqui. 
 >> Então, tudo isso dito, vamos nos afastar da memória por um segundo 
 e de volta aos ponteiros. 
 Aqui está a coisa mais importante a lembrar 
 quando começamos a trabalhar com ponteiros. 
 Um ponteiro nada mais é do que um endereço. 
 Vou dizer de novo porque é tão importante, 
 um ponteiro nada mais é do que um endereço. 
 Ponteiros são endereços para locais na memória onde vivem variáveis. 
 Sabendo que se torna um pouco mais fácil trabalhar com eles. 
 Outra coisa que gosto de fazer é ter 
 de diagramas representando visualmente o que está acontecendo com várias linhas de código. 

Hindi: 
 यह मेरी स्मृति जैसा दिख सकता है। 
 >> और बस विशेष रूप से यहाँ पांडित्य हो, जब 
 हम स्मृति पते के बारे में बात कर रहे हैं जो हम आमतौर पर करते हैं 
 हेक्साडेसिमल नोटेशन का उपयोग कर ऐसा करें। 
 तो क्यों न हम इन सभी को दशमलव से षोडश आधारी संकेतन में बदल दें 
 सिर्फ इसलिए कि आमतौर पर हम स्मृति का संदर्भ देते हैं। 
 इसलिए 19 के माध्यम से 0 होने के बजाय, जो हमारे पास है वह शून्य है 
 x शून्य से शून्य X1 तीन। 
 वे 20 बाइट्स हैं जो हमारे पास हैं या हम इस छवि को देख रहे हैं 
 यहीं। 
 >> तो यह सब कहा जा रहा है, चलो एक सेकंड के लिए स्मृति से दूर कदम रखें 
 और वापस संकेत करने के लिए। 
 यहां सबसे महत्वपूर्ण बात याद रखना है 
 जैसा कि हम संकेत के साथ काम करना शुरू करते हैं। 
 एक सूचक एक पते से ज्यादा कुछ नहीं है। 
 मैं इसे फिर से कहूंगा क्योंकि यह महत्वपूर्ण है, 
 एक सूचक एक पते से ज्यादा कुछ नहीं है। 
 संकेत स्मृति में उन स्थानों के पते हैं जहां चर रहते हैं। 
 यह जानते हुए कि उनके साथ काम करना थोड़ा आसान हो जाता है। 
 एक और चीज जो मुझे करना पसंद है वह है सॉर्ट करना 
 आरेखों का नेत्रहीन रूप से प्रतिनिधित्व करना कि कोड की विभिन्न लाइनों के साथ क्या हो रहा है। 

Chinese: 
这就是我的记忆。 
 >>在这里特别要学究
我们通常在谈论内存地址
使用十六进制表示法。 
那么为什么不将所有这些都从十进制转换为十六进制
仅仅因为那是我们通常所说的内存。 
所以我们不是0到19，而是0 
 x零到零x1三。 
这些是我们拥有的或正在此图中查看的20个字节的内存
就在这儿。 
 >>因此，我们要离开内存一秒钟
并返回指针。 
这是要记住的最重要的事情
当我们开始使用指针时。 
指针不过是一个地址。 
我再说一遍，因为它很重要， 
指针不过是一个地址。 
指针是内存中变量所在位置的地址。 
知道与他们一起工作会变得容易一些。 
我想做的另一件事是排序
直观地表示各种代码行所发生的事情的图表。 

Modern Greek (1453-): 
 αυτό μπορεί να μοιάζει με τη μνήμη μου. 
 >> Και απλά να είστε ιδιαίτερα πεντανόστιμος εδώ, πότε 
 μιλάμε για διευθύνσεις μνήμης που συνήθως χρησιμοποιούμε 
 να το κάνετε χρησιμοποιώντας δεκαεξαδικές σημειώσεις. 
 Τόσο γιατί να μην μετατρέψουμε όλα αυτά από δεκαδική σε δεκαεξαδική συμβολική συμβολική μορφή 
 ακριβώς επειδή αυτό είναι γενικά το πώς αναφέρουμε τη μνήμη. 
 Έτσι, αντί να είναι 0 έως 19, αυτό που έχουμε είναι μηδέν 
 x μηδέν έως μηδέν x1 τρία. 
 Αυτά είναι τα 20 byte μνήμης που έχουμε ή κοιτάζουμε σε αυτή την εικόνα 
 ακριβώς εδώ. 
 >> Έτσι, όλα αυτά που λέγαμε, ας βγούμε από τη μνήμη για ένα δευτερόλεπτο 
 και πίσω στους δείκτες. 
 Εδώ είναι το πιο σημαντικό πράγμα που πρέπει να θυμάστε 
 καθώς αρχίζουμε να δουλεύουμε με δείκτες. 
 Ένας δείκτης δεν είναι τίποτα περισσότερο από μια διεύθυνση. 
 Θα το ξαναδώ γιατί είναι τόσο σημαντικό, 
 ένας δείκτης δεν είναι παρά μια διεύθυνση. 
 Οι δείκτες είναι διευθύνσεις σε τοποθεσίες στη μνήμη όπου ζουν οι μεταβλητές. 
 Γνωρίζοντας ότι γίνεται ελαφρώς ευκολότερο να συνεργαστούμε μαζί τους. 
 Ένα άλλο πράγμα που μου αρέσει να κάνω είναι να το κάνω 
 των διαγραμμάτων που αντιπροσωπεύουν οπτικά το τι συμβαίνει με διάφορες γραμμές κώδικα. 

Italian: 
 questo è come potrebbe apparire la mia memoria. 
 >> Ed essere particolarmente pedanti qui, quando 
 stiamo parlando di indirizzi di memoria che di solito 
 farlo usando le notazioni esadecimali. 
 Quindi perché non convertiamo tutti questi da notazione decimale a esadecimale 
 solo perché in genere è così che ci riferiamo alla memoria. 
 Quindi, invece di essere da 0 a 19, quello che abbiamo è zero 
 x zero attraverso zero x1 tre. 
 Questi sono i 20 byte di memoria che abbiamo o che stiamo guardando in questa immagine 
 giusto qui. 
 >> Quindi, detto tutto ciò, allontaniamoci dalla memoria per un secondo 
 e torna ai puntatori. 
 Ecco la cosa più importante da ricordare 
 mentre iniziamo a lavorare con i puntatori. 
 Un puntatore non è altro che un indirizzo. 
 Lo dirò di nuovo perché è così importante, 
 un puntatore non è altro che un indirizzo. 
 I puntatori sono indirizzi verso posizioni in memoria in cui vivono le variabili. 
 Sapendo che, si spera, diventa un po 'più facile lavorare con loro. 
 Un'altra cosa che mi piace fare è ordinare 
 di diagrammi che rappresentano visivamente ciò che sta accadendo con varie righe di codice. 

French: 
 voici à quoi pourrait ressembler ma mémoire. 
 >> Et soyez particulièrement pédant ici, quand 
 nous parlons d'adresses de mémoire que nous avons habituellement 
 faites-le en utilisant des notations hexadécimales. 
 Alors pourquoi ne convertissons-nous pas tous ces éléments de la notation décimale en notation hexadécimale 
 juste parce que c'est généralement ainsi que nous nous référons à la mémoire. 
 Donc, au lieu d'être de 0 à 19, ce que nous avons est zéro 
 x zéro à zéro x1 trois. 
 Ce sont les 20 octets de mémoire que nous avons ou que nous regardons dans cette image 
 ici. 
 >> Donc, tout cela étant dit, éloignons-nous de la mémoire pendant une seconde 
 et retour aux pointeurs. 
 Voici la chose la plus importante à retenir 
 que nous commençons à travailler avec des pointeurs. 
 Un pointeur n'est rien d'autre qu'une adresse. 
 Je le répète parce que c'est si important, 
 un pointeur n'est rien d'autre qu'une adresse. 
 Les pointeurs sont des adresses vers des emplacements en mémoire où vivent des variables. 
 Sachant qu'il devient, espérons-le, un peu plus facile de travailler avec eux. 
 Une autre chose que j'aime faire est de trier 
 de diagrammes représentant visuellement ce qui se passe avec différentes lignes de code. 

German: 
 So könnte mein Gedächtnis aussehen. 
 >> Und sei hier besonders pedantisch, wenn 
 Wir sprechen über Speicheradressen, die wir normalerweise haben 
 Verwenden Sie dazu hexadezimale Notationen. 
 Warum konvertieren wir nicht alle diese von der Dezimal- in die Hexadezimalschreibweise? 
 Nur weil wir uns im Allgemeinen so auf das Gedächtnis beziehen. 
 Anstatt also 0 bis 19 zu sein, haben wir Null 
 x null bis null x1 drei. 
 Dies sind die 20 Bytes Speicher, die wir haben oder die wir in diesem Bild betrachten 
 genau hier. 
 >> Wenn das alles gesagt ist, lassen Sie uns für eine Sekunde aus dem Gedächtnis treten 
 und zurück zu den Zeigern. 
 Hier ist das Wichtigste, an das Sie sich erinnern sollten 
 wie wir anfangen mit Zeigern zu arbeiten. 
 Ein Zeiger ist nichts anderes als eine Adresse. 
 Ich werde es noch einmal sagen, weil es so wichtig ist, 
 Ein Zeiger ist nichts anderes als eine Adresse. 
 Zeiger sind Adressen an Stellen im Speicher, an denen Variablen leben. 
 Zu wissen, dass es hoffentlich ein bisschen einfacher wird, mit ihnen zu arbeiten. 
 Eine andere Sache, die ich gerne mache, ist Sortieren 
 von Diagrammen, die visuell darstellen, was mit verschiedenen Codezeilen passiert. 

Dutch: 
 dit is hoe mijn geheugen eruit zou kunnen zien. 
 >> En wees gewoon bijzonder pedant hier, wanneer 
 we hebben het over geheugenadressen die we gewoonlijk hebben 
 doe dit met hexadecimale notaties. 
 Dus waarom zetten we ze niet allemaal om van decimale naar hexadecimale notatie 
 gewoon omdat dat over het algemeen is hoe we naar geheugen verwijzen. 
 Dus in plaats van 0 tot en met 19 te zijn, is wat we hebben nul 
 x nul tot nul x1 drie. 
 Dat zijn de 20 bytes geheugen die we hebben of waar we naar kijken in deze afbeelding 
 hier. 
 Al met al dat gezegd zijnde, laten we even een seconde uit de herinnering stappen 
 en terug naar verwijzingen. 
 Dit is het belangrijkste om te onthouden 
 als we beginnen te werken met pointers. 
 Een aanwijzer is niets meer dan een adres. 
 Ik zeg het nog een keer omdat het zo belangrijk is, 
 een aanwijzer is niets meer dan een adres. 
 Aanwijzers zijn adressen naar locaties in het geheugen waar variabelen leven. 
 Wetende dat het hopelijk een beetje makkelijker wordt om ermee te werken. 
 Een ander ding dat ik graag doe, is sorteren 
 diagrammen die visueel weergeven wat er gebeurt met verschillende coderegels. 

English: 
this is what my memory might look like.
>> And just be particularly pedantic here, when
we're talking about memory addresses we usually
do so using hexadecimal notations.
So why don't we convert all of these from decimal to hexadecimal notation
just because that's generally how we refer to memory.
So instead of being 0 through 19, what we have is zero
x zero through zero x1 three.
Those are the 20 bytes of memory that we have or we're looking at in this image
right here.
>> So all of that being said, let's step away from memory for a second
and back to pointers.
Here is the most important thing to remember
as we start working with pointers.
A pointer is nothing more than an address.
I'll say it again because it's that important,
a pointer is nothing more than an address.
Pointers are addresses to locations in memory where variables live.
Knowing that it becomes hopefully a little bit easier to work with them.
Another thing I like to do is to have sort
of diagrams visually representing what's happening with various lines of code.

Indonesian: 
 seperti inilah ingatanku. 
 >> Dan menjadi sangat jagoan di sini, kapan 
 kita berbicara tentang alamat memori yang biasanya kita 
 melakukannya dengan menggunakan notasi heksadesimal. 
 Jadi mengapa tidak kita konversi semua ini dari notasi desimal menjadi heksadesimal 
 hanya karena itu umumnya bagaimana kita merujuk ke memori. 
 Jadi alih-alih menjadi 0 hingga 19, yang kita miliki adalah nol 
 x nol hingga nol x1 tiga. 
 Itu adalah 20 byte memori yang kita miliki atau sedang kita lihat dalam gambar ini 
 disini. 
 >> Jadi semua yang dikatakan, mari kita menjauh dari ingatan sejenak 
 dan kembali ke petunjuk. 
 Inilah hal yang paling penting untuk diingat 
 ketika kami mulai bekerja dengan pointer. 
 Pointer tidak lebih dari sebuah alamat. 
 Saya akan mengatakannya lagi karena itu penting, 
 sebuah pointer tidak lebih dari sebuah alamat. 
 Pointer adalah alamat ke lokasi di memori tempat variabel tinggal. 
 Mengetahui bahwa menjadi mudah-mudahan sedikit lebih mudah untuk bekerja dengan mereka. 
 Hal lain yang ingin saya lakukan adalah memiliki semacam 
 diagram yang secara visual mewakili apa yang terjadi dengan berbagai baris kode. 

Chinese: 
這就是我的記憶。 
 >>在這里特別要學究
我們通常在談論內存地址
使用十六進製表示法。 
那麼為什麼不將所有這些都從十進制轉換為十六進制
僅僅因為那是我們通常所說的內存。 
所以我們不是0到19，而是0 
 x零到零x1三。 
這些是我們擁有的或正在此圖中查看的20個字節的內存
就在這兒。 
 >>因此，我們要離開內存一秒鐘
並返回指針。 
這是要記住的最重要的事情
當我們開始使用指針時。 
指針不過是一個地址。 
我再說一遍，因為它很重要， 
指針不過是一個地址。 
指針是內存中變量所在位置的地址。 
知道與他們一起工作會變得容易一些。 
我想做的另一件事是排序
直觀地表示各種代碼行所發生的事情的圖表。 

Arabic: 
 هذا ما قد تبدو ذاكرتي. 
 >> وكن مجرد متحذلق هنا ، متى 
 نتحدث عن عناوين الذاكرة التي عادة 
 تفعل ذلك باستخدام الرموز السداسية العشرية. 
 فلماذا لا نقوم بتحويل كل هذه من التدوين العشري إلى الست عشري 
 فقط لأن هذه هي الطريقة التي نشير بها إلى الذاكرة بشكل عام. 
 لذا بدلاً من أن نكون من 0 إلى 19 ، ما لدينا هو صفر 
 x صفر من خلال الصفر x1 ثلاثة. 
 هذه هي 20 بايت من الذاكرة التي لدينا أو ننظر إليها في هذه الصورة 
 هنا. 
 >> لذلك كل ما قيل ، دعنا نبتعد عن الذاكرة لثانية 
 والعودة إلى المؤشرات. 
 إليك أهم شيء يجب تذكره 
 عندما نبدأ العمل مع المؤشرات. 
 المؤشر ليس أكثر من عنوان. 
 سأقولها مرة أخرى لأنها مهمة للغاية ، 
 المؤشر ليس أكثر من عنوان. 
 المؤشرات هي عناوين المواقع في الذاكرة حيث تعيش المتغيرات. 
 مع العلم أنه يصبح من الأسهل قليلاً العمل معهم. 
 شيء آخر أحب أن أفعله هو أن أفرز 
 من الرسوم البيانية التي تمثل بصريا ما يحدث مع سطور مختلفة من التعليمات البرمجية. 

Dutch: 
 En we zullen dit een paar keer doen in aanwijzers, 
 en als we het ook hebben over dynamische geheugentoewijzing. 
 Omdat ik denk dat deze diagrammen bijzonder nuttig kunnen zijn. 
 >> Dus als ik bijvoorbeeld int k in mijn code zeg, wat gebeurt er dan? 
 Wat er eigenlijk gebeurt, is dat ik geheugen opzij zet voor mij, 
 maar ik denk er niet eens zo over na, ik 
 er graag over na te denken als een doos. 
 Ik heb een doos en deze is groen gekleurd omdat ik 
 kan gehele getallen in groene vakken plaatsen. 
 Als het een personage was, had ik misschien een blauwe doos. 
 Maar ik zeg altijd, als ik een box maak die gehele getallen kan bevatten 
 die doos is groen gekleurd. 
 En ik neem een ​​permanente marker en ik schrijf k op de zijkant ervan. 
 Dus ik heb een box genaamd k, waarin ik gehele getallen kan plaatsen. 
 Dus als ik int k zeg, gebeurt dat in mijn hoofd. 
 Als ik zeg dat k gelijk is aan vijf, wat doe ik dan? 
 Wel, ik doe er vijf in de doos, juist. 
 Dit is vrij eenvoudig, als ik int k zeg, maak dan een box genaamd k. 
 Als ik zeg dat k gelijk is aan 5, stop er dan vijf in de doos. 
 Hopelijk is dat niet zo'n grote sprong. 
 Hier gaat het echter een beetje interessant. 

Indonesian: 
 Dan kami akan melakukan ini beberapa kali dalam pointer, 
 dan ketika kita berbicara tentang alokasi memori dinamis juga. 
 Karena saya pikir diagram ini dapat sangat membantu. 
 >> Jadi jika saya katakan misalnya, int k dalam kode saya, apa yang terjadi? 
 Nah yang pada dasarnya terjadi adalah saya mendapatkan memori yang disisihkan untuk saya, 
 tapi aku bahkan tidak suka memikirkannya seperti itu, aku 
 suka berpikir tentang itu seperti sebuah kotak. 
 Saya punya kotak dan warnanya hijau karena saya 
 dapat menempatkan bilangan bulat di kotak hijau. 
 Jika itu karakter saya mungkin memiliki kotak biru. 
 Tapi saya selalu mengatakan, jika saya membuat kotak yang bisa menampung bilangan bulat 
 kotak itu berwarna hijau. 
 Dan saya mengambil spidol permanen dan saya menulis k di sampingnya. 
 Jadi saya punya kotak bernama k, di mana saya bisa meletakkan bilangan bulat. 
 Jadi ketika saya mengatakan int k, itulah yang terjadi di kepala saya. 
 Jika saya katakan k sama dengan lima, apa yang saya lakukan? 
 Yah, saya memasukkan lima dalam kotak, benar. 
 Ini cukup mudah, jika saya katakan int k, buat sebuah kotak bernama k. 
 Jika saya katakan k sama dengan 5, masukkan lima ke dalam kotak. 
 Semoga itu tidak terlalu banyak lompatan. 
 Di sinilah segala sesuatunya menjadi sedikit menarik. 

Modern Greek (1453-): 
 Και θα το κάνουμε αυτό μερικές φορές σε δείκτες, 
 και όταν μιλάμε για δυναμική κατανομή μνήμης επίσης. 
 Επειδή πιστεύω ότι αυτά τα διαγράμματα μπορούν να είναι ιδιαίτερα χρήσιμα. 
 >> Έτσι, αν λέω για παράδειγμα, int k στον κώδικα μου, τι συμβαίνει; 
 Λοιπόν, αυτό που συμβαίνει βασικά είναι ότι παίρνω μνήμη που έχει τεθεί κατά μέρος για μένα, 
 αλλά δεν μου αρέσει να το σκέφτομαι έτσι, εγώ 
 ήθελα να το σκεφτώ σαν κουτί. 
 Έχω ένα κουτί και είναι έγχρωμο πράσινο γιατί εγώ 
 μπορεί να βάλει ακεραίους σε πράσινα κουτιά. 
 Αν ήταν χαρακτήρας, θα μπορούσα να έχω ένα μπλε κουτί. 
 Αλλά πάντα λέω, αν δημιουργώ ένα κουτί που μπορεί να κρατήσει ακέραιους αριθμούς 
 αυτό το κουτί είναι έγχρωμο πράσινο. 
 Και παίρνω ένα μόνιμο δείκτη και γράφω k στο πλάι του. 
 Έτσι έχω ένα κουτί που ονομάζεται k, στο οποίο μπορώ να βάλω ακέραιους αριθμούς. 
 Έτσι όταν λέω int k, αυτό συμβαίνει στο κεφάλι μου. 
 Αν λέω k ισούται με πέντε, τι κάνω; 
 Λοιπόν, βάζω πέντε στο κουτί, σωστά. 
 Αυτό είναι αρκετά απλό, αν λέω int k, δημιουργήστε ένα κουτί που ονομάζεται k. 
 Αν λέω k ισούται με 5, βάλτε πέντε μέσα στο κουτί. 
 Ας ελπίσουμε ότι αυτό δεν είναι πάρα πολύ ένα άλμα. 
 Εδώ είναι που τα πράγματα πάνε λίγο ενδιαφέρον. 

Spanish: 
 Y haremos esto un par de veces en punteros, 
 y cuando hablamos de asignación dinámica de memoria también. 
 Porque creo que estos diagramas pueden ser particularmente útiles. 
 >> Entonces, si digo, por ejemplo, int k en mi código, ¿qué está pasando? 
 Bueno, lo que básicamente está sucediendo es que me estoy reservando memoria, 
 pero ni siquiera me gusta pensar así, yo 
 me gusta pensarlo como una caja. 
 Tengo una caja y es de color verde porque yo 
 puede poner enteros en cajas verdes. 
 Si fuera un personaje, podría tener una caja azul. 
 Pero siempre digo, si estoy creando una caja que pueda contener enteros 
 esa caja es de color verde. 
 Y tomo un marcador permanente y escribo k a un lado. 
 Entonces tengo una caja llamada k, en la que puedo poner enteros. 
 Entonces, cuando digo int k, eso es lo que pasa en mi cabeza. 
 Si digo que k es igual a cinco, ¿qué estoy haciendo? 
 Bueno, pongo cinco en la caja, correcto. 
 Esto es bastante sencillo, si digo int k, cree un cuadro llamado k. 
 Si digo que k es igual a 5, pon cinco en el cuadro. 
 Esperemos que eso no sea un gran salto. 
 Aquí es donde las cosas van un poco interesantes sin embargo. 

Chinese: 
我们将在指针中执行几次， 
当我们谈到动态内存分配时。 
因为我认为这些图可能特别有用。 
 >>因此，例如，如果我在代码中说int k，这是怎么回事？ 
嗯，基本上正在发生的事情是我为我预留了内存， 
但我什至不喜欢那样思考，我
喜欢像盒子一样思考。 
我有一个盒子，它是绿色的，因为我
可以将整数放在绿色框中。 
如果是字符，我可能会有一个蓝色框。 
但是我总是说，如果我要创建一个可以容纳整数的盒子
那个盒子是绿色的。 
然后我拿一个永久性标记，并在其侧面写下k。 
因此，我有一个名为k的框，可以在其中放入整数。 
因此，当我说int k时，这就是我的想法。 
如果我说k等于5，那我在做什么？ 
好吧，我在盒子里放了五个，对。 
这很简单，如果我说int k，则创建一个名为k的框。 
如果我说k等于5，则将5放入方框中。 
希望这不是一个很大的飞跃。 
虽然这里有些有趣。 

Arabic: 
 وسنفعل ذلك عدة مرات في مؤشرات ، 
 وعندما نتحدث عن تخصيص الذاكرة الديناميكية أيضًا. 
 لأنني أعتقد أن هذه المخططات يمكن أن تكون مفيدة بشكل خاص. 
 >> لذا إذا قلت على سبيل المثال ، int k في الكود الخاص بي ، ماذا يحدث؟ 
 حسنًا ، ما يحدث بشكل أساسي هو أنني أضع الذاكرة جانبًا بالنسبة لي ، 
 لكنني لا أحب حتى التفكير في الأمر على هذا النحو ، أنا 
 أحب أن أفكر في الأمر مثل مربع. 
 لدي صندوق ولونه أخضر لأنني 
 يمكن وضع الأعداد الصحيحة في المربعات الخضراء. 
 إذا كانت شخصية فقد يكون لدي صندوق أزرق. 
 لكنني أقول دائمًا ، إذا كنت أقوم بإنشاء صندوق يمكنه استيعاب الأعداد الصحيحة 
 هذا المربع باللون الأخضر. 
 وأخذ علامة دائمة وأكتب k على جانبها. 
 لذا لدي صندوق يسمى k ، يمكنني وضع الأعداد الصحيحة فيه. 
 لذلك عندما أقول int k ، هذا ما يحدث في رأسي. 
 إذا قلت k تساوي خمسة ، ماذا أفعل؟ 
 حسنًا ، أنا أضع خمسة في الصندوق ، صحيح. 
 هذا بسيط جدًا ، إذا قلت int k ، فأنشئ صندوقًا يسمى k. 
 إذا قلت k تساوي 5 ، ضع خمسة في الصندوق. 
 آمل ألا تكون هذه قفزة كبيرة. 
 هنا حيث تسير الأمور إلى حد ما مثيرة للاهتمام. 

Chinese: 
我們將在指針中執行幾次， 
當我們談到動態內存分配時。 
因為我認為這些圖可能特別有用。 
 >>因此，例如，如果我在代碼中說int k，這是怎麼回事？ 
嗯，基本上正在發生的事情是我為我預留了內存， 
但我什至不喜歡那樣思考，我
喜歡像盒子一樣思考。 
我有一個盒子，它是綠色的，因為我
可以將整數放在綠色框中。 
如果是字符，我可能會有一個藍色框。 
但是我總是說，如果我要創建一個可以容納整數的盒子
那個盒子是綠色的。 
然後我拿一個永久性標記，並在其側面寫下k。 
因此，我有一個名為k的框，可以在其中放入整數。 
因此，當我說int k時，這就是我的想法。 
如果我說k等於5，那我在做什麼？ 
好吧，我在盒子裡放了五個，對。 
這很簡單，如果我說int k，則創建一個名為k的框。 
如果我說k等於5，則將5放入方框中。 
希望這不是一個很大的飛躍。 
雖然這裡有些有趣。 

Hindi: 
 और हम इस बिंदु पर दो बार करेंगे, 
 और जब हम गतिशील मेमोरी आवंटन के बारे में बात करते हैं। 
 क्योंकि मुझे लगता है कि ये चित्र विशेष रूप से सहायक हो सकते हैं। 
 >> इसलिए यदि मैं उदाहरण के लिए कहूं, तो मेरे कोड में इंट, क्या हो रहा है? 
 अच्छी तरह से मूल रूप से क्या हो रहा है, मेरे लिए मेमोरी सेट अलग है, 
 लेकिन मैं इसके बारे में ऐसा सोचना भी पसंद नहीं करता, मैं 
 एक बॉक्स की तरह इसके बारे में सोचना पसंद करते हैं। 
 मेरे पास एक बॉक्स है और यह हरे रंग का है क्योंकि मैं 
 हरे बॉक्स में पूर्णांक डाल सकते हैं। 
 यदि यह एक चरित्र होता तो मेरे पास एक ब्लू बॉक्स होता। 
 लेकिन मैं हमेशा कहता हूं, अगर मैं एक बॉक्स बना रहा हूं जो पूर्णांकों को पकड़ सकता है 
 वह बॉक्स हरे रंग का है। 
 और मैं एक स्थायी मार्कर लेता हूं और मैं इसके किनारे पर k लिखता हूं। 
 तो मेरे पास k नामक एक बॉक्स है, जिसमें मैं पूर्णांक डाल सकता हूं। 
 इसलिए जब मैं int k कहता हूं, तो मेरे दिमाग में यही होता है। 
 अगर मैं कहूं कि k पाँच के बराबर है, तो मैं क्या कर रहा हूँ? 
 ठीक है, मैं बॉक्स में पाँच डाल रहा हूँ, ठीक है। 
 यह बहुत सीधा है, अगर मैं int k कहता हूं, k नामक एक बॉक्स बनाएं। 
 अगर मैं कहूं कि कश्मीर 5 के बराबर है, तो बॉक्स में पांच रखो। 
 उम्मीद है कि बहुत अधिक छलांग नहीं है। 
 यहाँ जहाँ चीजें थोड़ी दिलचस्प हैं। 

English: 
And we'll do this a couple of times in pointers,
and when we talk about dynamic memory allocation as well.
Because I think that these diagrams can be particularly helpful.
>> So if I say for example, int k in my code, what is happening?
Well what's basically happening is I'm getting memory set aside for me,
but I don't even like to think about it like that, I
like to think about it like a box.
I have a box and it's colored green because I
can put integers in green boxes.
If it was a character I might have a blue box.
But I always say, if I'm creating a box that can hold integers
that box is colored green.
And I take a permanent marker and I write k on the side of it.
So I have a box called k, into which I can put integers.
So when I say int k, that's what happens in my head.
If I say k equals five, what am I doing?
Well, I'm putting five in the box, right.
This is pretty straightforward, if I say int k, create a box called k.
If I say k equals 5, put five into the box.
Hopefully that's not too much of a leap.
Here's where things go a little interesting though.

Japanese: 
これをポインタで数回行います
動的メモリ割り当てについても説明します。 
これらの図は特に役立つと思うので。 
 >>たとえば、コードでint kと言った場合、何が起こっているのでしょうか。 
さて、基本的に何が起こっているのかは、私のためにメモリを取っておくことです。 
でもそんなこと考えたくないし
箱のように考えるのが好きです。 
私は箱を持っています、そして私が
緑色のボックスに整数を入れることができます。 
キャラクターだったら青い箱があるかもしれません。 
しかし、整数を保持できるボックスを作成している場合、私は常に言います
その箱は緑色です。 
そして私はパーマネントマーカーを取り、その横にkと書きます。 
だから私は整数を入れることができるkと呼ばれる箱を持っています。 
だから私がint kと言うとき、それは私の頭の中で起こっていることです。 
 kが5に等しいと言う場合、私は何をしていますか？ 
ええと、私は箱に5個入れています。 
これは非常に簡単です。intkと言う場合は、kというボックスを作成します。 
 kが5に等しいと言ったら、ボックスに5を入れます。 
うまくいけば、それはそれほど大きな進歩ではありません。 
ただし、ここで少し面白くなります。 

Korean: 
 그리고 우리는 이것을 포인터로 몇 번 할 것입니다. 
 동적 메모리 할당에 대해서도 이야기 할 때 
 이 다이어그램이 특히 도움이 될 수 있다고 생각하기 때문입니다. 
 >> 예를 들어 내 코드에서 int k라고하면 어떻게됩니까? 
 기본적으로 일어나고있는 일은 메모리를 따로 보관 해 두는 것입니다. 
 하지만 난 그렇게 생각하고 싶지도 않아요 
 상자처럼 생각하고 싶습니다. 
 상자가 있는데 초록색으로 표시되어 있기 때문에 
 녹색 상자에 정수를 넣을 수 있습니다. 
 그것이 문자라면 파란색 상자가있을 수 있습니다. 
 그러나 항상 정수를 보유 할 수있는 상자를 만들면 항상 말합니다. 
 그 상자는 초록색입니다. 
 그리고 나는 영구적 인 마커를 가지고 옆에 k를 씁니다. 
 그래서 k라는 상자가 있는데 정수를 넣을 수 있습니다. 
 내가 int k라고 말할 때, 그것은 내 머리에서 일어나는 일입니다. 
 k가 5라고하면 어떻게해야합니까? 
 글쎄, 난 상자에 5 개 넣었 어 
 int k라고하면 k라는 상자를 만듭니다. 
 k가 5라고 말하면 상자에 5를 넣으십시오. 
 잘만되면 그것은 도약의 많지 않다. 
 그래도 조금 흥미로운 부분이 있습니다. 

Turkish: 
 Ve bunu birkaç kez işaretçilerle yapacağız, 
 ve dinamik bellek tahsisi hakkında da konuştuğumuzda. 
 Çünkü bu diyagramların özellikle yararlı olabileceğini düşünüyorum. 
 >> Yani örneğin kodumda int k dersem ne oluyor? 
 Temel olarak olan şey, hafızayı benim için ayırıyorum, 
 ama ben böyle düşünmeyi bile sevmiyorum, 
 bir kutu gibi düşünmeyi seviyorum. 
 Bir kutum var ve yeşil renkte çünkü 
 tamsayıları yeşil kutulara koyabilir. 
 Eğer bir karakter olsaydı mavi kutum olabilir. 
 Ama her zaman söylüyorum, eğer tamsayıları tutabilecek bir kutu oluşturursam 
 bu kutu yeşil renklidir. 
 Kalıcı bir marker alıyorum ve yanına k yazıyorum. 
 Yani tamsayı koyabileceğim k adında bir kutum var. 
 Yani int k dediğimde kafamda olan budur. 
 K'nin beşe eşit olduğunu söylersem ne yapıyorum? 
 Kutuya beş tane koyuyorum, tamam. 
 Bu oldukça basittir, int k dersem k adlı bir kutu oluşturun. 
 K'nin 5'e eşit olduğunu söylersem, beşi kutuya koyun. 
 Umarım bu bir sıçrama değildir. 
 Burada işlerin biraz ilginç olduğu yer. 

French: 
 Et nous le ferons quelques fois dans des pointeurs, 
 et lorsque nous parlons également d'allocation dynamique de mémoire. 
 Parce que je pense que ces diagrammes peuvent être particulièrement utiles. 
 >> Donc, si je dis par exemple, int k dans mon code, que se passe-t-il? 
 Eh bien, ce qui se passe essentiellement, c'est que je mets de la mémoire de côté, 
 mais je n'aime même pas y penser comme ça, je 
 aime y penser comme une boîte. 
 J'ai une boîte et elle est de couleur verte parce que je 
 peut mettre des entiers dans des cases vertes. 
 Si c'était un personnage, je pourrais avoir une boîte bleue. 
 Mais je dis toujours, si je crée une boîte qui peut contenir des entiers 
 cette boîte est de couleur verte. 
 Et je prends un marqueur permanent et j'écris k sur le côté. 
 J'ai donc une boîte appelée k, dans laquelle je peux mettre des entiers. 
 Donc quand je dis int k, c'est ce qui se passe dans ma tête. 
 Si je dis que k est égal à cinq, que fais-je? 
 Eh bien, j'en mets cinq dans la boîte, à droite. 
 C'est assez simple, si je dis int k, créez une boîte appelée k. 
 Si je dis que k est égal à 5, mettez-en cinq dans la case. 
 Espérons que ce ne soit pas trop un saut. 
 Voici où les choses deviennent un peu intéressantes. 

Russian: 
 И мы сделаем это пару раз в указателях, 
 и когда мы говорим о динамическом распределении памяти, а также. 
 Потому что я думаю, что эти диаграммы могут быть особенно полезны. 
 >> Так что, если я скажу, например, int k в моем коде, что происходит? 
 Что ж, в основном происходит то, что я откладываю память для себя, 
 но я даже не люблю думать об этом, я 
 нравится думать об этом, как коробка. 
 У меня есть коробка, и она окрашена в зеленый цвет, потому что я 
 можно положить целые числа в зеленые поля. 
 Если бы это был персонаж, у меня могла бы быть синяя коробка. 
 Но я всегда говорю, если я создаю коробку, которая может содержать целые числа 
 эта коробка окрашена в зеленый цвет. 
 И я беру постоянный маркер, и я пишу k на его стороне. 
 Итак, у меня есть поле с именем k, в которое я могу положить целые числа. 
 Поэтому, когда я говорю int k, это то, что происходит в моей голове. 
 Если я скажу, что k равно пяти, что я делаю? 
 Ну, я кладу пять в коробку, верно. 
 Это довольно просто, если я скажу int k, создайте коробку с именем k. 
 Если я скажу, что k равно 5, положите пять в коробку. 
 Надеюсь, это не слишком большой скачок. 
 Здесь все идет немного интересно, хотя. 

Italian: 
 E lo faremo un paio di volte in puntatori, 
 e quando parliamo anche di allocazione dinamica della memoria. 
 Perché penso che questi diagrammi possano essere particolarmente utili. 
 >> Quindi, se dico, ad esempio, nel mio codice, cosa sta succedendo? 
 Bene, ciò che sta praticamente accadendo è che sto mettendo da parte la memoria per me, 
 ma non mi piace nemmeno pensarci così, io 
 piace pensarci come una scatola. 
 Ho una scatola ed è di colore verde perché io 
 può mettere numeri interi in caselle verdi. 
 Se fosse un personaggio potrei avere una scatola blu. 
 Ma dico sempre, se sto creando una scatola che può contenere numeri interi 
 quella scatola è di colore verde. 
 E prendo un pennarello indelebile e scrivo k sul lato di esso. 
 Quindi ho una casella chiamata k, in cui posso inserire numeri interi. 
 Quindi quando dico int k, è quello che succede nella mia testa. 
 Se dico k è uguale a cinque, cosa sto facendo? 
 Bene, ne sto mettendo cinque nella scatola, giusto. 
 Questo è abbastanza semplice, se dico int k, crea una casella chiamata k. 
 Se dico che k equivale a 5, mettine cinque nella casella. 
 Spero che non sia un gran salto. 
 Ecco dove le cose vanno un po 'interessanti però. 

Portuguese: 
 E faremos isso algumas vezes em ponteiros, 
 e quando falamos sobre alocação dinâmica de memória também. 
 Porque acho que esses diagramas podem ser particularmente úteis. 
 >> Então, se eu disser, por exemplo, int k no meu código, o que está acontecendo? 
 Bem, o que está basicamente acontecendo é que estou ficando com a memória reservada para mim, 
 mas eu nem gosto de pensar assim, eu 
 gostaria de pensar sobre isso como uma caixa. 
 Eu tenho uma caixa e é verde porque eu 
 pode colocar números inteiros em caixas verdes. 
 Se fosse um personagem, eu poderia ter uma caixa azul. 
 Mas eu sempre digo, se estou criando uma caixa que pode conter números inteiros 
 essa caixa é colorida de verde. 
 E eu pego um marcador permanente e escrevo k ao lado dele. 
 Então, eu tenho uma caixa chamada k, na qual eu posso colocar números inteiros. 
 Então, quando digo int k, é o que acontece na minha cabeça. 
 Se eu disser que k é igual a cinco, o que estou fazendo? 
 Bem, estou colocando cinco na caixa, certo. 
 Isso é bem direto, se eu disser int k, crie uma caixa chamada k. 
 Se eu disser que k é igual a 5, coloque cinco na caixa. 
 Espero que isso não seja um salto demais. 
 Aqui é onde as coisas vão um pouco interessantes. 

German: 
 Und wir werden dies ein paar Mal in Zeigern tun, 
 und wenn wir auch über dynamische Speicherzuweisung sprechen. 
 Weil ich denke, dass diese Diagramme besonders hilfreich sein können. 
 >> Wenn ich zum Beispiel int k in meinem Code sage, was passiert dann? 
 Nun, was im Grunde passiert, ist, dass ich Speicher für mich reserviert bekomme, 
 aber ich denke nicht mal gerne so darüber nach, ich 
 denke gerne darüber nach wie eine Kiste. 
 Ich habe eine Schachtel und sie ist grün gefärbt, weil ich 
 kann ganze Zahlen in grüne Kästchen setzen. 
 Wenn es ein Charakter wäre, hätte ich vielleicht eine blaue Box. 
 Aber ich sage immer, wenn ich eine Box erstelle, die ganze Zahlen enthalten kann 
 Diese Box ist grün gefärbt. 
 Und ich nehme einen dauerhaften Marker und schreibe k daneben. 
 Ich habe also eine Box namens k, in die ich ganze Zahlen einfügen kann. 
 Wenn ich also int k sage, passiert das in meinem Kopf. 
 Wenn ich sage, dass k gleich fünf ist, was mache ich dann? 
 Nun, ich lege fünf in die Schachtel, richtig. 
 Dies ist ziemlich einfach, wenn ich int k sage, erstellen Sie eine Box namens k. 
 Wenn ich sage, dass k gleich 5 ist, geben Sie fünf in die Box. 
 Hoffentlich ist das kein allzu großer Sprung. 
 Hier läuft es allerdings etwas interessant. 

Dutch: 
 Als ik int * pk zeg, zelfs als ik niet weet wat dit noodzakelijkerwijs betekent, 
 het heeft duidelijk iets te maken met een geheel getal. 
 Dus ik ga deze doos groen-achtig kleuren, 
 Ik weet dat het iets te maken heeft met een geheel getal, 
 maar het is zelf geen geheel getal, omdat het een int-ster is. 
 Er is iets anders aan. 
 Dus een geheel getal is betrokken, maar verder is het 
 niet veel anders dan waar we het over hadden. 
 Het is een doos, het heeft een label, het draagt ​​een label pk, 
 en het kan int sterren vasthouden, wat die ook zijn. 
 Ze hebben duidelijk iets te maken met gehele getallen. 
 Hier is echter de laatste regel. 
 Als ik pk = & k zeg, whoa, wat is er net gebeurd, toch? 
 Dus dit willekeurige getal, schijnbaar willekeurig getal, wordt daar in de doos gegooid. 
 Het enige dat is, is dat pk het adres van k krijgt. 
 Dus ik blijf waar k in het geheugen leeft, het adres, het adres van de bytes. 
 Alles wat ik doe is dat ik zeg dat waarde is wat ik ga 
 om in mijn doos te doen, genaamd pk. 

Japanese: 
 int * pkと言うと、どういう意味かわからなくても、 
それは明らかに整数と関係があります。 
このボックスを緑っぽく塗ります
私はそれが整数と関係があることを知っています、 
しかし、それは整数の星なので、それ自体は整数ではありません。 
それについては少し違う点があります。 
つまり整数が関係しますが、それ以外の場合は
私たちが話していたものとあまり変わらない。 
それは箱であり、ラベルがあり、ラベルpkを着用しています。 
そして、それが何であれ、intスターを保持することができます。 
明らかに整数と関係があります。 
これが最後の行です。 
 pk =＆k、whoa、と言うと、何が起こったのでしょう？ 
したがって、この乱数（一見すると乱数のように見えます）は、そこのボックスに入れられます。 
つまり、pkはkのアドレスを取得します。 
だから私はkがメモリのどこに住んでいるか、そのアドレス、そのバイトのアドレスにこだわっています。 
私がしているのは、その価値は私が行っていることだと言っているだけです
 pkという私の箱の中に入れます。 

Korean: 
 int * pk라고 말하면 이것이 무엇을 의미하는지 잘 모르더라도 
 그것은 분명히 정수와 관련이 있습니다. 
 이 상자를 초록색으로 칠하겠습니다. 
 정수와 관련이 있다는 것을 알고 있습니다. 
 그러나 정수 자체는 정수가 아니기 때문에 정수 자체가 아닙니다. 
 그것에 대해 약간 다른 것이 있습니다. 
 정수가 관련되어 있지만 그렇지 않으면 
 우리가 말했던 것과 크게 다르지 않습니다. 
 상자이고, 레이블이 있고, pk 레이블이 붙어 있습니다. 
 그리고 그것이 무엇이든간에 별을 붙잡을 수 있습니다. 
 그들은 분명히 정수와 관련이 있습니다. 
 마지막 줄은 다음과 같습니다. 
 pk = & k라고하면, 방금 무슨 일이 있었나요? 
 따라서이 임의의 숫자, 겉보기 임의의 숫자는 상자에 던져집니다. 
 즉, pk는 k의 주소를 가져옵니다. 
 그래서 k가 메모리, 주소, 바이트 주소에 머무르는 곳을 고집하고 있습니다. 
 내가하고있는 것은 그 가치가 내가 가고있는 것이라고 말하는 것입니다 
 pk라는 상자 안에 넣습니다. 

English: 
If I say int*pk, well even if I don't know what this necessarily means,
it's clearly got something to do with an integer.
So I'm going to color this box green-ish,
I know it's got something to do with an integer,
but it's not an integer itself, because it's an int star.
There's something slightly different about it.
So an integer's involved, but otherwise it's
not too different from what we were talking about.
It's a box, its got a label, it's wearing a label pk,
and it's capable of holding int stars, whatever those are.
They have something to do with integers, clearly.
Here's the last line though.
If I say pk=&k, whoa, what just happened, right?
So this random number, seemingly random number, gets thrown into the box there.
All that is, is pk gets the address of k.
So I'm sticking where k lives in memory, its address, the address of its bytes.
All I'm doing is I'm saying that value is what I'm going
to put inside of my box called pk.

Portuguese: 
 Se eu disser int * pk, bem, mesmo que eu não saiba o que isso significa necessariamente, 
 claramente tem algo a ver com um número inteiro. 
 Então, eu vou colorir essa caixa de verde, 
 Eu sei que tem algo a ver com um número inteiro, 
 mas não é um número inteiro, porque é uma estrela int. 
 Há algo um pouco diferente nisso. 
 Então, um número inteiro está envolvido, mas, caso contrário, é 
 não muito diferente do que estávamos falando. 
 É uma caixa, tem uma etiqueta, está usando uma etiqueta, 
 e é capaz de conter estrelas int, sejam elas quais forem. 
 Eles têm algo a ver com números inteiros, claramente. 
 Aqui está a última linha. 
 Se eu disser pk = & k, uau, o que aconteceu, certo? 
 Portanto, esse número aleatório, aparentemente aleatório, é jogado na caixa de lá. 
 Tudo o que é, é pk, obtém o endereço de k. 
 Então, eu estou mantendo onde k mora na memória, seu endereço, o endereço de seus bytes. 
 Tudo o que estou fazendo é dizer que valor é o que vou 
 para colocar dentro da minha caixa chamada pk. 

Hindi: 
 अगर मैं int * pk कहूं, तो भी अगर मुझे नहीं पता कि इसका क्या मतलब है, 
 यह स्पष्ट रूप से एक पूर्णांक के साथ कुछ करने के लिए मिला है। 
 इसलिए मैं इस बॉक्स को हरे-ईश के रंग में रंगने जा रहा हूं, 
 मुझे पता है कि इसे पूर्णांक के साथ कुछ करना है, 
 लेकिन यह एक पूर्णांक नहीं है, क्योंकि यह एक इंट सितारा है। 
 इसके बारे में कुछ अलग है। 
 तो एक पूर्णांक शामिल है, लेकिन अन्यथा यह है 
 हम जिस बारे में बात कर रहे थे, उससे बहुत अलग नहीं। 
 यह एक बॉक्स है, इसका एक लेबल मिला है, यह एक लेबल pk पहन रहा है, 
 और यह इंट स्टार्स रखने में सक्षम है, जो भी हैं। 
 उन्हें पूर्णांक के साथ स्पष्ट रूप से कुछ करना है। 
 यहाँ हालांकि अंतिम पंक्ति है। 
 अगर मैं कहूँ कि pk = & k, वाह, क्या अभी हुआ है, है ना? 
 तो यह यादृच्छिक संख्या, प्रतीत होता है यादृच्छिक संख्या, वहाँ बॉक्स में फेंक दिया जाता है। 
 सब है, पीके है कश्मीर का पता मिलता है। 
 इसलिए मैं चिपके हुए हूं जहां k स्मृति में रहता है, उसका पता, उसके बाइट का पता। 
 मैं जो कुछ कर रहा हूं वह सब मैं कह रहा हूं कि मूल्य वही है जो मैं जा रहा हूं 
 मेरे बॉक्स के अंदर रखने के लिए जिसे pk कहा जाता है। 

Arabic: 
 إذا قلت int * pk ، حسنًا حتى إذا لم أكن أعرف ما يعنيه هذا بالضرورة ، 
 من الواضح أن لها علاقة بالعدد الصحيح. 
 لذلك سأقوم بتلوين هذا الصندوق باللون الأخضر ، 
 أعلم أن لها علاقة بالعدد الصحيح ، 
 لكنه ليس عددًا صحيحًا ، لأنه نجم دولي. 
 هناك شيء مختلف قليلاً عنه. 
 لذا فإن العدد الصحيح متورط ، ولكن بخلاف ذلك 
 لا يختلف كثيرا عما كنا نتحدث عنه. 
 إنه صندوق ، يحتوي على ملصق ، إنه يرتدي تسمية pk ، 
 وهي قادرة على حمل النجوم الدولية مهما كانت. 
 من الواضح أن لهم علاقة بالأعداد الصحيحة. 
 إليك السطر الأخير بالرغم من ذلك. 
 إذا قلت pk = & k ، قف ، ماذا حدث للتو ، أليس كذلك؟ 
 لذلك يتم طرح هذا الرقم العشوائي ، الذي يبدو أنه رقم عشوائي ، في المربع هناك. 
 كل ما هو pk يحصل على عنوان k. 
 لذا فأنا أصرخ حيث يعيش k في الذاكرة وعنوانه وعنوان بايته. 
 كل ما أفعله هو أنني أقول أن القيمة هي ما سأفعله 
 لوضع داخل صندوقي يسمى pk. 

French: 
 Si je dis int * pk, eh bien même si je ne sais pas ce que cela signifie nécessairement, 
 cela a clairement quelque chose à voir avec un entier. 
 Je vais donc colorier cette boîte en vert, 
 Je sais que ça a quelque chose à voir avec un entier, 
 mais ce n'est pas un entier lui-même, car c'est une étoile int. 
 Il y a quelque chose de légèrement différent. 
 Donc un entier est impliqué, mais sinon c'est 
 pas trop différent de ce dont nous parlions. 
 C'est une boîte, elle a une étiquette, elle porte une étiquette pk, 
 et il est capable de contenir des étoiles int, quelles qu'elles soient. 
 Ils ont clairement quelque chose à voir avec les nombres entiers. 
 Voici cependant la dernière ligne. 
 Si je dis pk = & k, whoa, qu'est-ce qui vient de se passer, non? 
 Donc, ce nombre aléatoire, apparemment aléatoire, est jeté dans la boîte là-bas. 
 Tout ce qui est, pk obtient l'adresse de k. 
 Je reste donc où k habite en mémoire, son adresse, l'adresse de ses octets. 
 Tout ce que je fais c'est dire que la valeur est ce que je veux 
 mettre à l'intérieur de ma boîte appelée pk. 

Chinese: 
如果我說int * pk，即使我不知道這意味著什麼， 
顯然與整數有關。 
所以我要把這個盒子塗成綠色
我知道跟整數有關係
但它本身不是整數，因為它是int星。 
有點不同。 
所以涉及到一個整數，否則
與我們所說的沒有太大不同。 
這是一個盒子，上面有標籤，上面有標籤pk， 
不管它們是什麼，它都有能力容納int星。 
顯然，它們與整數有關。 
這是最後一行。 
如果我說pk =＆k，哇，剛才發生了什麼，對不對？ 
因此，這個隨機數（看似隨機數）被扔到了那裡。 
就是說，pk獲取k的地址。 
所以我堅持將k保留在內存中的位置，它的地址，它的字節地址。 
我正在做的是說價值就是我要去的東西
放在我叫pk的盒子裡

German: 
 Wenn ich int * pk sage, auch wenn ich nicht weiß, was dies unbedingt bedeutet, 
 Es hat eindeutig etwas mit einer ganzen Zahl zu tun. 
 Also werde ich diese Schachtel grün färben, 
 Ich weiß, dass es etwas mit einer ganzen Zahl zu tun hat. 
 aber es ist keine ganze Zahl selbst, weil es ein int-Stern ist. 
 Es hat etwas anderes. 
 Es handelt sich also um eine Ganzzahl, aber ansonsten ist es so 
 nicht zu verschieden von dem, worüber wir gesprochen haben. 
 Es ist eine Schachtel, es hat ein Etikett, es trägt ein Etikett pk, 
 und es ist in der Lage, int Sterne zu halten, was auch immer diese sind. 
 Sie haben eindeutig etwas mit ganzen Zahlen zu tun. 
 Hier ist die letzte Zeile. 
 Wenn ich pk = & k sage, whoa, was ist gerade passiert, richtig? 
 Diese Zufallszahl, scheinbar zufällige Zahl, wird dort in die Schachtel geworfen. 
 Alles was ist, ist pk bekommt die Adresse von k. 
 Also bleibe ich dort, wo k im Speicher lebt, seine Adresse, die Adresse seiner Bytes. 
 Ich sage nur, dass Wert das ist, was ich gehe 
 in meine Box namens pk zu legen. 

Chinese: 
如果我说int * pk，即使我不知道这意味着什么， 
显然与整数有关。 
所以我要把这个盒子涂成绿色
我知道跟整数有关系
但它本身不是整数，因为它是int星。 
有点不同。 
所以涉及到一个整数，否则
与我们所说的没有太大不同。 
这是一个盒子，上面有标签，上面有标签pk， 
不管它们是什么，它都有能力容纳int星。 
显然，它们与整数有关。 
这是最后一行。 
如果我说pk =＆k，哇，刚才发生了什么，对不对？ 
因此，这个随机数（看似随机数）被扔到了那里。 
就是说，pk获取k的地址。 
所以我坚持将k保留在内存中的位置，它的地址，它的字节地址。 
我正在做的是说价值就是我要去的东西
放在我叫pk的盒子里

Spanish: 
 Si digo int * pk, bueno, incluso si no sé lo que esto necesariamente significa, 
 claramente tiene algo que ver con un número entero. 
 Así que voy a colorear esta caja de verde-ish, 
 Sé que tiene algo que ver con un número entero, 
 pero no es un entero en sí, porque es una estrella int. 
 Hay algo ligeramente diferente al respecto. 
 Entonces un número entero está involucrado, pero por lo demás es 
 no muy diferente de lo que estábamos hablando. 
 Es una caja, tiene una etiqueta, lleva una etiqueta pk, 
 y es capaz de contener estrellas int, sean cuales sean. 
 Tienen algo que ver con los enteros, claramente. 
 Aquí está la última línea sin embargo. 
 Si digo pk = & k, whoa, ¿qué acaba de pasar, verdad? 
 Entonces, este número aleatorio, aparentemente número aleatorio, se arroja a la caja allí. 
 Todo lo que es, es pk obtiene la dirección de k. 
 Así que me quedo donde k vive en la memoria, su dirección, la dirección de sus bytes. 
 Todo lo que estoy haciendo es decir que el valor es lo que voy 
 poner dentro de mi caja llamada pk. 

Indonesian: 
 Jika saya mengatakan int * pk, meskipun saya tidak tahu apa artinya ini, 
 itu jelas ada hubungannya dengan integer. 
 Jadi saya akan mewarnai kotak ini hijau-ish, 
 Saya tahu itu ada hubungannya dengan bilangan bulat, 
 tapi itu bukan bilangan bulat itu sendiri, karena itu adalah bintang int. 
 Ada sesuatu yang sedikit berbeda tentang itu. 
 Jadi bilangan bulat terlibat, tetapi selain itu bilangan bulat 
 tidak terlalu berbeda dengan apa yang kita bicarakan. 
 Itu kotak, ada labelnya, pakai label pk, 
 dan itu mampu memegang bintang int, apa pun itu. 
 Mereka ada hubungannya dengan bilangan bulat, jelas. 
 Inilah baris terakhir. 
 Jika saya mengatakan pk = & k, whoa, apa yang baru saja terjadi, kan? 
 Jadi nomor acak ini, nomor acak, akan dimasukkan ke dalam kotak di sana. 
 Semua itu, adalah pk mendapat alamat k. 
 Jadi saya menempel di tempat tinggal k dalam memori, alamatnya, alamat byte-nya. 
 Yang saya lakukan hanyalah mengatakan bahwa nilai adalah apa yang saya lakukan 
 untuk dimasukkan ke dalam kotak saya yang disebut pk. 

Turkish: 
 İnt * pk dersem, bunun ne anlama geldiğini bilmesem bile, 
 açıkça bir tamsayı ile ilgili bir şey var. 
 Bu kutuyu yeşil renklendireceğim, 
 Bunun bir tamsayı ile ilgisi olduğunu biliyorum, 
 ama bu bir tamsayı değil, çünkü bir int yıldızı. 
 Biraz farklı bir şey var. 
 Yani bir tamsayı dahil, ama aksi halde 
 bahsettiğimiz şeyden çok farklı değil. 
 Bu bir kutu, bir etiketi var, bir etiket pk giyiyor, 
 ve ne olursa olsun int yıldızları tutabilir. 
 Açıkça tamsayılarla ilgili bir şeyleri var. 
 İşte son satır. 
 Pk = & k diyorum, whoa, az önce ne oldu, değil mi? 
 Bu rastgele sayı, görünüşte rastgele sayı, oradaki kutuya atılır. 
 Bütün bunlar, pk k adresini alır. 
 Bu yüzden k'nin bellekte nerede yaşadığını, adresini, baytlarının adresini yapıştırıyorum. 
 Tek yaptığım, değerin gittiğim şey olduğunu söylüyorum 
 pk adındaki kutumun içine koymak. 

Italian: 
 Se dico int * pk, beh anche se non so cosa significhi necessariamente questo, 
 ha chiaramente qualcosa a che fare con un numero intero. 
 Quindi colorerò questa casella di verde, 
 So che ha qualcosa a che fare con un numero intero, 
 ma non è un numero intero, perché è una stella int. 
 C'è qualcosa di leggermente diverso. 
 Quindi è coinvolto un intero, ma per il resto lo è 
 non troppo diverso da quello di cui stavamo parlando. 
 È una scatola, ha un'etichetta, indossa un'etichetta pk, 
 ed è in grado di contenere stelle int, qualunque esse siano. 
 Hanno qualcosa a che fare con gli interi, chiaramente. 
 Ecco l'ultima riga però. 
 Se dico pk = & k, whoa, cosa è appena successo, giusto? 
 Quindi questo numero casuale, apparentemente un numero casuale, viene gettato nella scatola lì. 
 Tutto ciò che è, è pk ottiene l'indirizzo di k. 
 Quindi rimango dove k vive nella memoria, il suo indirizzo, l'indirizzo dei suoi byte. 
 Tutto quello che sto facendo è dire che il valore è quello che sto andando 
 per mettere dentro la mia scatola chiamata pk. 

Russian: 
 Если я скажу int * pk, хорошо, даже если я не знаю, что это обязательно означает, 
 это явно связано с целым числом. 
 Так что я собираюсь покрасить эту коробку в зеленый цвет, 
 Я знаю, что это связано с целым числом, 
 но это не само целое число, потому что это целая звезда. 
 В этом есть что-то немного другое. 
 Таким образом, целое число участвует, но в противном случае это 
 не слишком отличается от того, о чем мы говорили. 
 Это коробка, на ней есть этикетка, на ней этикетка ПК, 
 и он способен удерживать звезды, какими бы они ни были. 
 Очевидно, они имеют отношение к целым числам. 
 Вот последняя строка, хотя. 
 Если я скажу pk = & k, воу, что только что произошло, верно? 
 Так что это случайное число, кажущееся случайным числом, выбрасывается туда. 
 Все, что есть, это pk получает адрес k. 
 Поэтому я придерживаюсь того, где k живет в памяти, его адрес, адрес его байтов. 
 Все, что я делаю, я говорю, что ценность - это то, что я собираюсь 
 положить внутрь моей коробки под названием рк. 

Modern Greek (1453-): 
 Αν λέω int * pk, καλά ακόμα κι αν δεν ξέρω τι σημαίνει αυτό αναγκαστικά, 
 έχει ξεκάθαρα κάτι να κάνει με έναν ακέραιο αριθμό. 
 Έτσι πηγαίνω στο χρώμα αυτού του κουτιού πράσινο-ish, 
 Ξέρω ότι έχει κάτι να κάνει με έναν ακέραιο αριθμό, 
 αλλά δεν είναι ο ίδιος ο ακέραιος αριθμός, επειδή είναι ένα αστέρι int. 
 Υπάρχει κάτι λίγο διαφορετικό γι 'αυτό. 
 Έτσι, ένας ακέραιος συμμετέχει, αλλά διαφορετικά είναι 
 όχι πολύ διαφορετικό από αυτό που μιλούσαμε. 
 Είναι ένα κιβώτιο, έχει μια ετικέτα, φέρει ετικέτα pk, 
 και είναι σε θέση να κρατά int άστρα, όποια και αν είναι αυτά. 
 Έχουν κάτι να κάνουν με τους ακεραίους, σαφώς. 
 Εδώ είναι η τελευταία γραμμή όμως. 
 Αν πω pk = & k, whoa, τι συνέβη, έτσι; 
 Έτσι, αυτός ο τυχαίος αριθμός, φαινομενικά τυχαίος αριθμός, ρίχνεται στο κουτί εκεί. 
 Το μόνο που είναι, είναι το pk παίρνει τη διεύθυνση του k. 
 Επομένως, κολλάω όπου το k ζει στη μνήμη, τη διεύθυνση του, τη διεύθυνση των bytes του. 
 Το μόνο που κάνω είναι ότι λέω ότι η αξία είναι αυτό που πηγαίνω 
 να βάλω μέσα στο κουτί μου που ονομάζεται pk. 

Indonesian: 
 Dan karena hal-hal ini adalah petunjuk, dan karena melihat 
 pada string seperti nol x delapan nol c tujuh empat delapan 
 dua nol mungkin tidak terlalu berarti. 
 Ketika kita secara umum memvisualisasikan pointer, kita sebenarnya melakukannya sebagai pointer. 
 Pk memberi kita informasi yang kita butuhkan untuk menemukan k dalam memori. 
 Jadi pada dasarnya pk memiliki panah di dalamnya. 
 Dan jika kita berjalan sepanjang panah itu, bayangkan 
 itu sesuatu yang bisa kau jalani, jika kita berjalan di sepanjang panah, 
 di ujung panah itu, kita akan menemukan lokasi di memori 
 dimana k tinggal. 
 Dan itu sangat penting karena begitu kita tahu di mana k tinggal, 
 kita dapat mulai bekerja dengan data di dalam lokasi memori itu. 
 Meskipun kita mendapatkan sedikit di depan diri kita untuk saat ini. 
 >> Jadi apa itu pointer? 
 Pointer adalah item data yang nilainya adalah alamat memori. 
 Itu yang nol x delapan nol terjadi, itu adalah alamat memori. 
 Itu adalah lokasi di memori. 
 Dan jenis pointer menggambarkan jenisnya 
 data yang akan Anda temukan di alamat memori itu. 
 Jadi ada bagian bintang int benar. 

Russian: 
 И потому, что эти вещи являются указателями, и потому что глядя 
 на строку, как ноль х восемь ноль с семь четыре восемь 
 два нуля, вероятно, не очень значимы. 
 Когда мы обычно визуализируем указатели, мы фактически делаем это как указатели. 
 ПК дает нам информацию, которую мы должны найти в памяти. 
 Таким образом, в основном у pk есть стрелка. 
 И если мы пройдем всю длину этой стрелы, представьте 
 это то, что вы можете идти, если мы идем по длине стрелки, 
 в самом конце этой стрелки, мы найдем место в памяти 
 где К живет. 
 И это действительно важно, потому что когда мы знаем, где живет k, 
 мы можем начать работать с данными внутри этой ячейки памяти. 
 Хотя сейчас мы немного опережаем себя. 
 >> Так что указатель? 
 Указатель - это элемент данных, значением которого является адрес памяти. 
 Это было то, что происходило ноль х восемь ноль, это был адрес памяти. 
 Это было место в памяти. 
 И тип указателя описывает вид 
 данных вы найдете по этому адресу памяти. 
 Так что есть часть звезды справа. 

Modern Greek (1453-): 
 Και επειδή αυτά τα πράγματα είναι δείκτες, και επειδή αναζητούν 
 σε μια συμβολοσειρά όπως το μηδέν x οκτώ μηδέν c επτά τέσσερα οκτώ 
 δύο μηδέν δεν είναι πιθανό να έχει πολύ νόημα. 
 Όταν βλέπουμε γενικά τους δείκτες, το κάνουμε ως δείκτες. 
 Το Pk μας δίνει τις πληροφορίες που πρέπει να βρούμε k στη μνήμη. 
 Έτσι, βασικά το pk έχει ένα βέλος μέσα του. 
 Και αν περπατήσουμε το μήκος αυτού του βέλους, φανταστείτε 
 είναι κάτι που μπορείτε να περπατήσετε, εάν περπατάμε κατά μήκος του βέλους, 
 στην άκρη αυτού του βέλους, θα βρούμε τη θέση στη μνήμη 
 όπου ζ ζει. 
 Και αυτό είναι πραγματικά σημαντικό επειδή μόλις μάθουμε πού ζ ζει, 
 μπορούμε να αρχίσουμε να δουλεύουμε με τα δεδομένα μέσα σε αυτή τη θέση μνήμης. 
 Αν και παίρνουμε ένα teeny κομμάτι μπροστά από εμάς για τώρα. 
 >> Τι είναι λοιπόν ένας δείκτης; 
 Ένας δείκτης είναι ένα στοιχείο δεδομένων του οποίου η τιμή είναι μια διεύθυνση μνήμης. 
 Αυτό ήταν που συμβαίνει με μηδέν x οκτώ μηδέν, ήταν μια διεύθυνση μνήμης. 
 Αυτή ήταν μια θέση στη μνήμη. 
 Και ο τύπος ενός δείκτη περιγράφει το είδος 
 των δεδομένων που θα βρείτε στη διεύθυνση μνήμης. 
 Επομένως, υπάρχει το σωστό μέρος int star. 

Chinese: 
而且因為這些東西都是指針，並且因為
在像零x八零c七四八的字符串
兩個零可能不是很有意義。 
通常，當我們可視化指針時，實際上是將其作為指針。 
 Pk為我們提供了在內存中找到k所需的信息。 
因此，基本上pk中有一個箭頭。 
如果我們走那箭的長度，想像一下
如果我們沿著箭頭的長度行走，那是可以繼續前進的東西， 
在該箭頭的最尖端，我們將在內存中找到位置
 k住的地方。 
這真的很重要，因為一旦我們知道k住在哪裡， 
我們可以開始使用該內存位置中的數據。 
儘管我們現在要領先一步。 
 >>那麼什麼是指針？ 
指針是數據項，其值為存儲地址。 
那就是零x八個零的東西，那是一個內存地址。 
那是內存中的位置。 
指針的類型描述了那種
您將在該內存地址找到的數據量。 
因此，有一個int star部分。 

Turkish: 
 Çünkü bunlar işaretçiler ve çünkü 
 sıfır x sekiz gibi bir dizede sıfır c yedi dört sekiz 
 iki sıfır muhtemelen çok anlamlı değildir. 
 Genelde işaretçileri görselleştirdiğimizde, bunu aslında işaretçiler olarak yaparız. 
 Pk bize hafızada k'yi bulmamız için gereken bilgiyi verir. 
 Yani temelde pk'nin içinde bir ok var. 
 Ve eğer o okun uzunluğu boyunca yürürsek, 
 eğer ok boyunca yürüyebileceğin bir şey, eğer ok boyunca yürürsek, 
 o okun en ucunda, yeri hafızada bulacağız 
 k yaşıyor. 
 Ve bu gerçekten önemli çünkü k'nin nerede yaşadığını bildiğimizde, 
 o bellek konumunun içindeki verilerle çalışmaya başlayabiliriz. 
 Şimdilik ufacık bir adım öne geçmemize rağmen. 
 >> Peki işaretçi nedir? 
 İşaretçi, değeri bir bellek adresi olan bir veri öğesidir. 
 Bu sıfır x sekiz sıfır şey devam ediyordu, bu bir bellek adresiydi. 
 Bu hafızadaki bir yerdi. 
 Ve bir işaretçi türü, 
 Bu bellek adresinde bulacağınız veriler. 
 Yani int yıldız kısmı doğru. 

Arabic: 
 ولأن هذه الأشياء هي مؤشرات ، ولأن النظر 
 بسلسلة مثل صفر × ثمانية صفر ج سبعة أربعة ثمانية 
 2 صفر ربما ليس له معنى كبير. 
 عندما نتخيل المؤشرات بشكل عام ، فإننا نقوم بذلك بالفعل كمؤشرات. 
 Pk يعطينا المعلومات التي نحتاجها للعثور على k في الذاكرة. 
 لذلك أساسا pk لديه سهم فيه. 
 وإذا مشينا على طول هذا السهم ، تخيل 
 إنه شيء يمكنك المشي عليه ، إذا مشينا على طول السهم ، 
 عند طرف هذا السهم ، سنجد الموقع في الذاكرة 
 حيث يعيش k. 
 وهذا مهم حقًا لأنه بمجرد أن نعرف أين يعيش k ، 
 يمكننا البدء في العمل مع البيانات الموجودة داخل موقع الذاكرة. 
 على الرغم من أننا نتقدم قليلاً على أنفسنا في الوقت الحالي. 
 >> إذن ما هو المؤشر؟ 
 المؤشر هو عنصر بيانات قيمته عنوان ذاكرة. 
 كان ذلك أن الصفر × ثمانية أشياء تحدث ، كان ذلك عنوان ذاكرة. 
 كان ذلك مكانًا في الذاكرة. 
 ويصف نوع المؤشر النوع 
 من البيانات التي ستجدها في عنوان الذاكرة. 
 إذن هناك جزء النجم الصحيح. 

German: 
 Und weil diese Dinge Zeiger sind und weil sie schauen 
 bei einer Zeichenkette wie null x acht null c sieben vier acht 
 zwei Null ist wahrscheinlich nicht sehr aussagekräftig. 
 Wenn wir Zeiger im Allgemeinen visualisieren, tun wir dies tatsächlich als Zeiger. 
 Pk gibt uns die Informationen, die wir brauchen, um k im Speicher zu finden. 
 Also hat pk im Grunde einen Pfeil. 
 Und wenn wir die Länge dieses Pfeils gehen, stellen Sie sich vor 
 Es ist etwas, worauf man gehen kann, wenn wir entlang der Länge des Pfeils gehen. 
 Ganz oben auf diesem Pfeil finden wir den Speicherort 
 wo k lebt. 
 Und das ist wirklich wichtig, denn sobald wir wissen, wo k lebt, 
 Wir können beginnen, mit den Daten innerhalb dieses Speicherorts zu arbeiten. 
 Obwohl wir uns vorerst ein kleines Stück voraus sind. 
 >> Was ist also ein Zeiger? 
 Ein Zeiger ist ein Datenelement, dessen Wert eine Speicheradresse ist. 
 Das war das Null x Acht Null-Zeug, das war eine Speicheradresse. 
 Das war ein Ort in Erinnerung. 
 Und der Typ eines Zeigers beschreibt die Art 
 von Daten finden Sie an dieser Speicheradresse. 
 Da ist also der Int-Star-Teil richtig. 

Spanish: 
 Y porque estas cosas son punteros, y porque mirar 
 en una cadena como cero x ocho cero c siete cuatro ocho 
 dos cero probablemente no sea muy significativo. 
 Cuando generalmente visualizamos punteros, en realidad lo hacemos como punteros. 
 Pk nos da la información que necesitamos para encontrar k en la memoria. 
 Básicamente, pk tiene una flecha. 
 Y si caminamos la longitud de esa flecha, imagina 
 es algo sobre lo que puedes caminar, si caminamos a lo largo de la flecha, 
 en la punta de esa flecha, encontraremos la ubicación en la memoria 
 donde k vive 
 Y eso es realmente importante porque una vez que sabemos dónde vive k, 
 podemos comenzar a trabajar con los datos dentro de esa ubicación de memoria. 
 Aunque nos estamos adelantando un poco por ahora. 
 >> Entonces, ¿qué es un puntero? 
 Un puntero es un elemento de datos cuyo valor es una dirección de memoria. 
 Eso fue que estaban sucediendo cero x ocho cero cosas, esa era una dirección de memoria. 
 Esa fue una ubicación en la memoria. 
 Y el tipo de puntero describe el tipo 
 de datos que encontrará en esa dirección de memoria. 
 Así que ahí está la parte estrella de la derecha. 

Japanese: 
そして、これらはポインタであり、見ているため
ゼロxエイトゼロcセブンフォーエイトのような文字列で
 2つのゼロはおそらくあまり意味がありません。 
ポインターを一般的に視覚化する場合、実際にはポインターとして視覚化します。 
 Pkは、メモリ内でkを見つけるために必要な情報を提供します。 
つまり、基本的にpkには矢印が含まれています。 
そしてその矢印の長さを歩くと想像してみてください
それはあなたが歩くことができるものです、私たちが矢印の長さに沿って歩くなら、 
その矢印の先端で、メモリ内の場所を見つけます
 kが住んでいるところ。 
そして、kがどこに住んでいるか知ったら、 
そのメモリ位置内のデータで作業を開始できます。 
今のところ、私たちは自分よりも少し進んでいますが。 
 >>では、ポインタとは何ですか？ 
ポインタは、値がメモリアドレスであるデータ項目です。 
それは、ゼロx 8ゼロが起こっていることであり、それはメモリアドレスでした。 
それは記憶の中の場所でした。 
そして、ポインタのタイプは種類を説明します
そのメモリアドレスで見つけるデータの。 
ですからint星の部分は正しいです。 

Hindi: 
 और क्योंकि ये चीजें संकेत हैं, और क्योंकि देख रहे हैं 
 शून्य x आठ शून्य c सात चार आठ की तरह एक स्ट्रिंग पर 
 दो शून्य शायद बहुत सार्थक नहीं हैं। 
 जब हम आम तौर पर पॉइंटर्स की कल्पना करते हैं, तो हम वास्तव में पॉइंटर्स के रूप में ऐसा करते हैं। 
 Pk हमें वह जानकारी देता है जिसकी हमें स्मृति में k खोजने की आवश्यकता है। 
 तो मूल रूप से pk में एक तीर है। 
 और अगर हम उस तीर की लंबाई पर चलते हैं, तो कल्पना करें 
 यह कुछ ऐसा है जिस पर आप चल सकते हैं, यदि हम तीर की लंबाई के साथ चलते हैं, 
 उस तीर के बहुत सिरे पर, हम स्मृति में स्थान पाएंगे 
 कहाँ रहता है। 
 और यह वास्तव में महत्वपूर्ण है क्योंकि एक बार जब हम जानते हैं कि कश्मीर कहाँ रहता है, 
 हम उस मेमोरी लोकेशन के डेटा के साथ काम करना शुरू कर सकते हैं। 
 हालांकि हम अब के लिए खुद से आगे एक नन्हा सा हो रहे हैं। 
 >> तो एक सूचक क्या है? 
 पॉइंटर एक डेटा आइटम है जिसका मान मेमोरी एड्रेस है। 
 यह शून्य शून्य आठ शून्य सामान चल रहा था, यह एक स्मृति पता था। 
 यह स्मृति में एक स्थान था। 
 और एक पॉइंटर के प्रकार का वर्णन करता है 
 उस स्मृति पते पर आपको मिलेगा डेटा। 
 इसलिए इंट स्टार भाग सही है। 

Korean: 
 이런 것들이 포인터이기 때문에 
 0 x 8 0 c 7 4 8과 같은 문자열에서 
 두 개의 0은 그다지 의미가 없습니다. 
 일반적으로 포인터를 시각화 할 때 실제로 포인터로 그렇게합니다. 
 Pk는 메모리에서 k를 찾는 데 필요한 정보를 제공합니다. 
 기본적으로 pk에는 화살표가 있습니다. 
 그 화살표의 길이를 걷는다면 
 화살표의 길이를 따라 걸 으면 걸을 수있는 것입니다. 
 그 화살표의 맨 끝에서, 우리는 메모리에서 위치를 찾을 것입니다 
 k가 사는 곳. 
 k가 어디에 있는지 알면 정말 중요합니다. 
 해당 메모리 위치 내의 데이터 작업을 시작할 수 있습니다. 
 우리는 지금 우리 자신보다 조금 앞서고 있습니다. 
 >> 그래서 포인터는 무엇입니까? 
 포인터는 값이 메모리 주소 인 데이터 항목입니다. 
 그것은 제로 x 여덟 제로 물건이 진행되는 것이었고, 그것은 메모리 주소였습니다. 
 그것은 기억의 장소였습니다. 
 포인터의 종류는 종류를 설명합니다 
 해당 메모리 주소에서 찾을 수 있습니다. 
 그래서 int star 부분이 있습니다. 

Chinese: 
而且因为这些东西都是指针，并且因为
在像零x八零c七四八的字符串
两个零可能不是很有意义。 
通常，当我们可视化指针时，实际上是将其作为指针。 
 Pk为我们提供了在内存中找到k所需的信息。 
因此，基本上pk中有一个箭头。 
如果我们走那箭的长度，想像一下
如果我们沿着箭头的长度行走，那是可以继续前进的东西， 
在该箭头的最尖端，我们将在内存中找到位置
 k住的地方。 
这真的很重要，因为一旦我们知道k住在哪里， 
我们可以开始使用该内存位置中的数据。 
尽管我们现在要领先一步。 
 >>那么什么是指针？ 
指针是数据项，其值为存储地址。 
那就是零x八个零的东西，那是一个内存地址。 
那是内存中的位置。 
指针的类型描述了那种
您将在该内存地址找到的数据量。 
因此，有一个int star部分。 

French: 
 Et parce que ces choses sont des pointeurs, et parce que regarder 
 à une chaîne comme zéro x huit zéro c sept quatre huit 
 deux zéro n'est probablement pas très significatif. 
 Lorsque nous visualisons généralement des pointeurs, nous le faisons en fait en tant que pointeurs. 
 Pk nous donne les informations dont nous avons besoin pour trouver k en mémoire. 
 Donc, fondamentalement, pk contient une flèche. 
 Et si nous marchons le long de cette flèche, imaginez 
 c'est quelque chose sur lequel on peut marcher, si on marche le long de la flèche, 
 à la pointe de cette flèche, nous trouverons l'emplacement en mémoire 
 où k habite. 
 Et c'est vraiment important car une fois qu'on sait où k habite, 
 nous pouvons commencer à travailler avec les données à l'intérieur de cet emplacement de mémoire. 
 Bien que nous ayons un peu d'avance sur nous pour l'instant. 
 >> Alors qu'est-ce qu'un pointeur? 
 Un pointeur est un élément de données dont la valeur est une adresse mémoire. 
 C'était ça, zéro x huit zéro, c'était une adresse mémoire. 
 C'était un endroit en mémoire. 
 Et le type d'un pointeur décrit le type 
 des données que vous trouverez à cette adresse mémoire. 
 Il y a donc la partie int star à droite. 

Portuguese: 
 E porque essas coisas são ponteiros, e porque olhar 
 em uma corda como zero x oito zero c sete quatro oito 
 dois zero provavelmente não são muito significativos. 
 Quando geralmente visualizamos ponteiros, na verdade o fazemos como ponteiros. 
 Pk nos fornece as informações necessárias para encontrar k na memória. 
 Então basicamente o pk tem uma flecha. 
 E se andarmos o comprimento dessa flecha, imagine 
 é algo em que você pode caminhar, se caminharmos ao longo da flecha, 
 na ponta dessa seta, encontraremos o local na memória 
 onde k mora. 
 E isso é realmente importante porque, quando sabemos onde k mora, 
 podemos começar a trabalhar com os dados dentro desse local de memória. 
 Embora estejamos nos adiantando um pouco, por enquanto. 
 >> Então, o que é um ponteiro? 
 Um ponteiro é um item de dados cujo valor é um endereço de memória. 
 Era esse zero x oito zero acontecendo, esse era um endereço de memória. 
 Esse era um local na memória. 
 E o tipo de um ponteiro descreve o tipo 
 de dados que você encontrará nesse endereço de memória. 
 Portanto, há a parte int star certa. 

Italian: 
 E perché queste cose sono puntatori, e perché guardare 
 a una stringa come zero x otto zero c sette quattro otto 
 due zero probabilmente non è molto significativo. 
 Quando generalmente visualizziamo puntatori, lo facciamo effettivamente come puntatori. 
 Pk ci fornisce le informazioni di cui abbiamo bisogno per trovare k in memoria. 
 Quindi in pratica pk ha una freccia. 
 E se percorriamo la lunghezza di quella freccia, immagina 
 è qualcosa su cui puoi camminare, se camminiamo lungo la lunghezza della freccia, 
 proprio sulla punta di quella freccia, troveremo la posizione in memoria 
 dove k vive. 
 E questo è davvero importante perché una volta che sappiamo dove vive k, 
 possiamo iniziare a lavorare con i dati all'interno di quella posizione di memoria. 
 Anche se per ora stiamo diventando un po 'più avanti di noi. 
 >> Quindi cos'è un puntatore? 
 Un puntatore è un elemento dati il ​​cui valore è un indirizzo di memoria. 
 Era quello zero x otto cose in corso, quello era un indirizzo di memoria. 
 Quella era una posizione nella memoria. 
 E il tipo di puntatore descrive il tipo 
 di dati che troverai a quell'indirizzo di memoria. 
 Quindi c'è la parte della stella int giusta. 

English: 
And because these things are pointers, and because looking
at a string like zero x eight zero c seven four eight
two zero is probably not very meaningful.
When we generally visualize pointers, we actually do so as pointers.
Pk gives us the information we need to find k in memory.
So basically pk has an arrow in it.
And if we walk the length of that arrow, imagine
it's something you can walk on, if we walk along the length of the arrow,
at the very tip of that arrow, we will find the location in memory
where k lives.
And that's really important because once we know where k lives,
we can start to work with the data inside of that memory location.
Though we're getting a teeny bit ahead of ourselves for now.
>> So what is a pointer?
A pointer is a data item whose value is a memory address.
That was that zero x eight zero stuff going on, that was a memory address.
That was a location in memory.
And the type of a pointer describes the kind
of data you'll find at that memory address.
So there's the int star part right.

Dutch: 
 En omdat deze dingen aanwijzingen zijn en omdat kijken 
 op een string als nul x acht nul c zeven vier acht 
 twee nul is waarschijnlijk niet erg betekenisvol. 
 Wanneer we over het algemeen pointers visualiseren, doen we dat eigenlijk als pointers. 
 Pk geeft ons de informatie die we nodig hebben om k in het geheugen te vinden. 
 Dus eigenlijk heeft pk een pijl erin. 
 En stel je voor dat we over de lengte van die pijl lopen 
 het is iets waar je op kunt lopen, als we langs de lengte van de pijl lopen, 
 helemaal bovenaan die pijl vinden we de locatie in het geheugen 
 waar k woont. 
 En dat is heel belangrijk, want als we eenmaal weten waar k woont, 
 we kunnen beginnen te werken met de gegevens in die geheugenlocatie. 
 Al lopen we voorlopig een stapje voor op onszelf. 
 >> Dus wat is een aanwijzer? 
 Een aanwijzer is een gegevensitem waarvan de waarde een geheugenadres is. 
 Dat was dat nul x acht nul dingen aan de hand, dat was een geheugenadres. 
 Dat was een locatie in het geheugen. 
 En het type aanwijzer beschrijft het soort 
 van gegevens die u op dat geheugenadres zult vinden. 
 Dus daar is het int-stergedeelte goed. 

Hindi: 
 अगर मैं उस तीर का अनुसरण करता हूं, तो यह मुझे एक स्थान पर ले जाने वाला है। 
 और वह स्थान, जो मुझे मेरे उदाहरण में मिलेगा, 
 हरे रंग का डिब्बा है। 
 यह एक पूर्णांक है, अगर मैं उस पते पर जाता हूं तो मुझे यही मिलेगा। 
 एक सूचक का डेटा प्रकार क्या वर्णन करता है 
 आपको वह मेमोरी एड्रेस मिल जाएगा। 
 तो यहाँ वास्तव में अच्छी बात है। 
 पॉइंटर्स हमें फंक्शन्स के बीच वेरिएबल पास करने की अनुमति देते हैं। 
 और वास्तव में चर को पार करते हैं और उनकी प्रतियां पास नहीं करते हैं। 
 क्योंकि अगर हमें पता है कि चर खोजने के लिए मेमोरी कहाँ है, 
 हमें इसकी प्रति बनाने की आवश्यकता नहीं है, हम बस उस स्थान पर जा सकते हैं 
 और उस चर के साथ काम करते हैं। 
 तो संक्षेप में एक कंप्यूटर वातावरण बनाने के संकेत में 
 असली दुनिया की तरह बहुत अधिक, सही। 
 >> तो यहाँ एक सादृश्य है। 
 मान लीजिए कि मेरे पास एक नोटबुक है, ठीक है, और यह नोटों से भरा है। 
 और मैं चाहूंगा कि आप इसे अपडेट करें। 
 आप एक फ़ंक्शन हैं जो नोट्स को अपडेट करते हैं, ठीक है। 
 जिस तरह से हम अब तक काम कर रहे हैं, क्या 

Portuguese: 
 Se eu seguir essa flecha, isso me levará a um local. 
 E nessa localização, o que vou encontrar lá no meu exemplo, 
 é uma caixa de cor verde. 
 É um número inteiro, é o que vou encontrar se for para esse endereço. 
 O tipo de dados de um ponteiro descreve quais 
 você encontrará nesse endereço de memória. 
 Então aqui está a coisa realmente legal. 
 Ponteiros nos permitem passar variáveis ​​entre funções. 
 E, na verdade, passa variáveis ​​e não passa cópias delas. 
 Porque se soubermos exatamente onde na memória encontrar uma variável, 
 não precisamos fazer uma cópia, podemos apenas ir para esse local 
 e trabalhe com essa variável. 
 Então, em essência, ponteiros meio que tornam um ambiente de computador 
 muito mais parecido com o mundo real, certo. 
 >> Então aqui está uma analogia. 
 Digamos que eu tenho um caderno, certo, e está cheio de anotações. 
 E eu gostaria que você o atualizasse. 
 Você é uma função que atualiza notas, certo. 
 Na maneira como trabalhamos até agora, o que 

Modern Greek (1453-): 
 Αν ακολουθήσω αυτό το βέλος, θα με οδηγήσει σε μια θέση. 
 Και αυτή η τοποθεσία, αυτό που θα βρω εκεί στο παράδειγμά μου, 
 είναι ένα πράσινο χρώμα κουτί. 
 Είναι ένας ακέραιος αριθμός, αυτό θα βρω αν πάω σε αυτή τη διεύθυνση. 
 Ο τύπος δεδομένων ενός δείκτη περιγράφει τι 
 θα βρείτε αυτή τη διεύθυνση μνήμης. 
 Έτσι, εδώ είναι το πραγματικά δροσερό πράγμα όμως. 
 Οι δείκτες μας επιτρέπουν να περάσουμε μεταβλητές μεταξύ λειτουργιών. 
 Και ουσιαστικά περάστε τις μεταβλητές και μην περάσετε αντίγραφα αυτών. 
 Επειδή αν γνωρίζουμε ακριβώς πού στη μνήμη να βρούμε μια μεταβλητή, 
 δεν χρειάζεται να κάνουμε ένα αντίγραφο του, μπορούμε απλά να πάμε σε εκείνη την τοποθεσία 
 και να εργαστείτε με αυτήν τη μεταβλητή. 
 Επομένως, στην ουσία οι δείκτες κάνουν ένα περιβάλλον υπολογιστή 
 πολύ περισσότερο σαν τον πραγματικό κόσμο, σωστά. 
 >> Έτσι, εδώ είναι μια αναλογία. 
 Ας πούμε ότι έχω ένα σημειωματάριο, σωστά, και είναι γεμάτο από σημειώσεις. 
 Και θα ήθελα να το ενημερώσετε. 
 Είστε μια λειτουργία που ενημερώνει τις σημειώσεις, σωστά. 
 Με τον τρόπο που εργαζόμαστε μέχρι τώρα, τι 

Korean: 
 화살표를 따라 가면 위치로 연결됩니다. 
 그리고 그 위치, 예에서 찾을 수있는 것은 
 녹색 상자입니다. 
 정수입니다. 해당 주소로 이동하면 찾을 수 있습니다. 
 포인터의 데이터 타입은 
 해당 메모리 주소에서 찾을 수 있습니다. 
 그래도 여기 정말 멋진 것이 있습니다. 
 포인터를 사용하면 함수 사이에 변수를 전달할 수 있습니다. 
 실제로 변수를 전달하고 사본을 전달하지 않습니다. 
 메모리에서 변수를 찾을 위치를 정확히 알고 있다면 
 사본을 만들 필요가 없습니다. 해당 위치로 이동하면됩니다. 
 그 변수로 작업하십시오. 
 본질적으로 포인터는 컴퓨터 환경을 만듭니다. 
 실세계와 훨씬 비슷합니다. 
 >> 여기에 비유가 있습니다. 
 내가 노트북을 가지고 있다고 가정 해 봅시다. 메모가 가득합니다. 
 그리고 당신이 그것을 업데이트하고 싶습니다. 
 당신은 메모를 업데이트하는 기능입니다. 
 우리가 지금까지 일한 방식으로 

Japanese: 
その矢印をたどると、ある場所に行くことができます。 
そしてその場所、私が私の例でそこに見つけるもの、 
緑色のボックスです。 
それは整数であり、そのアドレスに行くとそれがわかります。 
ポインターのデータ型は、 
そのメモリアドレスにあります。 
ですから、ここは本当にクールなことです。 
ポインターを使用すると、関数間で変数を渡すことができます。 
そして、実際には変数を渡し、それらのコピーは渡しません。 
変数を見つけるためのメモリ内の場所を正確に知っている場合、 
コピーを作成する必要はありません。その場所に移動できます
その変数を操作します。 
つまり、本質的にポインタはコンピュータ環境を作ります
実世界と同じくらいです
 >>だからここに類推があります。 
私がノートを持っているとしましょう、そしてそれはノートでいっぱいです。 
そして、それを更新してほしい。 
あなたは、ノートを更新する機能です。 
これまで取り組んできた方法で、 

English: 
If I follow that arrow, it's going to lead me to a location.
And that location, what I will find there in my example,
is a green colored box.
It's an integer, that's what I will find if I go to that address.
The data type of a pointer describes what
you will find at that memory address.
So here's the really cool thing though.
Pointers allow us to pass variables between functions.
And actually pass variables and not pass copies of them.
Because if we know exactly where in memory to find a variable,
we don't need to make a copy of it, we can just go to that location
and work with that variable.
So in essence pointers sort of make a computer environment
a lot more like the real world, right.
>> So here's an analogy.
Let's say that I have a notebook, right, and it's full of notes.
And I would like you to update it.
You are a function that updates notes, right.
In the way we've been working so far, what

German: 
 Wenn ich diesem Pfeil folge, führt mich das zu einem Ort. 
 Und dieser Ort, den ich dort in meinem Beispiel finden werde, 
 ist eine grün gefärbte Box. 
 Es ist eine ganze Zahl, das werde ich finden, wenn ich zu dieser Adresse gehe. 
 Der Datentyp eines Zeigers beschreibt was 
 Sie finden an dieser Speicheradresse. 
 Also hier ist die wirklich coole Sache. 
 Zeiger ermöglichen es uns, Variablen zwischen Funktionen zu übergeben. 
 Und tatsächlich Variablen übergeben und keine Kopien davon übergeben. 
 Denn wenn wir genau wissen, wo im Speicher eine Variable zu finden ist, 
 Wir brauchen keine Kopie davon zu machen, wir können einfach zu diesem Ort gehen 
 und arbeite mit dieser Variablen. 
 Im Wesentlichen machen Zeiger also eine Art Computerumgebung 
 viel mehr wie die reale Welt, richtig. 
 >> Hier ist eine Analogie. 
 Nehmen wir an, ich habe ein Notizbuch, richtig, und es ist voller Notizen. 
 Und ich möchte, dass Sie es aktualisieren. 
 Sie sind eine Funktion, die Notizen aktualisiert, richtig. 
 In der Art, wie wir bisher gearbeitet haben, was 

Dutch: 
 Als ik die pijl volg, leidt het me naar een locatie. 
 En die locatie, wat ik daar zal vinden in mijn voorbeeld, 
 is een groen gekleurde doos. 
 Het is een geheel getal, dat is wat ik zal vinden als ik naar dat adres ga. 
 Het gegevenstype van een aanwijzer beschrijft wat 
 u zult vinden op dat geheugenadres. 
 Dus hier is het echt coole ding. 
 Aanwijzers stellen ons in staat variabelen tussen functies door te geven. 
 En geef eigenlijk variabelen door en geef geen kopieën ervan door. 
 Want als we precies weten waar in het geheugen een variabele te vinden is, 
 we hoeven er geen kopie van te maken, we kunnen gewoon naar die locatie gaan 
 en werk met die variabele. 
 Dus in wezen maken pointers een soort computeromgeving 
 veel meer zoals de echte wereld, toch. 
 >> Dus hier is een analogie. 
 Laten we zeggen dat ik een notitieboekje heb, en dat staat vol met aantekeningen. 
 En ik zou graag willen dat je het bijwerkt. 
 Je bent een functie die notities bijwerkt, toch. 
 Zoals we tot nu toe hebben gewerkt, wat 

Indonesian: 
 Jika saya mengikuti panah itu, itu akan membawa saya ke suatu lokasi. 
 Dan lokasi itu, apa yang akan saya temukan di sana dalam contoh saya, 
 adalah kotak berwarna hijau. 
 Ini bilangan bulat, itulah yang akan saya temukan jika saya pergi ke alamat itu. 
 Tipe data dari pointer menjelaskan apa 
 Anda akan menemukan di alamat memori itu. 
 Jadi, inilah hal yang sangat keren. 
 Pointer memungkinkan kita untuk mengirimkan variabel antar fungsi. 
 Dan sebenarnya meneruskan variabel dan tidak meneruskan salinannya. 
 Karena jika kita tahu persis di mana dalam memori untuk menemukan variabel, 
 kita tidak perlu membuat salinannya, kita cukup pergi ke lokasi itu 
 dan bekerja dengan variabel itu. 
 Jadi pada intinya pointer semacam membuat lingkungan komputer 
 lebih seperti dunia nyata, benar. 
 >> Jadi inilah analoginya. 
 Katakanlah saya punya buku catatan, benar, dan penuh dengan catatan. 
 Dan saya ingin Anda memperbaruinya. 
 Anda adalah fungsi yang memperbarui catatan, benar. 
 Sejauh ini kami sudah bekerja, apa 

Chinese: 
如果我跟隨那個箭頭，它將帶我到一個位置。 
在我的示例中可以找到的那個位置， 
是一個綠色的盒子。 
這是一個整數，如果我去那個地址，那就是我會發現的。 
指針的數據類型描述了什麼
您會在該內存地址找到。 
所以這確實是很酷的事情。 
指針使我們能夠在函數之間傳遞變量。 
並且實際上傳遞變量而不傳遞變量的副本。 
因為如果我們確切地知道在內存中哪裡可以找到變量， 
我們不需要復制它，我們可以去那個地方
並使用該變量。 
因此，從本質上講，指針可以構成計算機環境
更像現實世界，對。 
 >>所以這是一個比喻。 
假設我有一個筆記本，對了，上面滿是筆記。 
我希望您進行更新。 
您是對筆記進行更新的功能。 
到目前為止，我們一直在努力

Italian: 
 Se seguo quella freccia, mi porterà in una posizione. 
 E quella posizione, quello che troverò lì nel mio esempio, 
 è una scatola di colore verde. 
 È un numero intero, è quello che troverò se vado a quell'indirizzo. 
 Il tipo di dati di un puntatore descrive cosa 
 troverai a quell'indirizzo di memoria. 
 Quindi ecco la cosa davvero interessante però. 
 I puntatori ci consentono di passare variabili tra le funzioni. 
 E in realtà passa variabili e non passa copie di esse. 
 Perché se sappiamo esattamente dove in memoria trovare una variabile, 
 non abbiamo bisogno di farne una copia, possiamo semplicemente andare in quella posizione 
 e lavora con quella variabile. 
 Quindi, in sostanza, i puntatori creano un ambiente informatico 
 molto più simile al mondo reale, giusto. 
 >> Quindi ecco un'analogia. 
 Diciamo che ho un quaderno, giusto, ed è pieno di appunti. 
 E vorrei che lo aggiornassi. 
 Sei una funzione che aggiorna le note, giusto. 
 Nel modo in cui abbiamo lavorato finora, cosa 

French: 
 Si je suis cette flèche, ça va me conduire à un endroit. 
 Et cet endroit, ce que je vais y trouver dans mon exemple, 
 est une boîte de couleur verte. 
 C'est un entier, c'est ce que je trouverai si je vais à cette adresse. 
 Le type de données d'un pointeur décrit ce 
 vous trouverez à cette adresse mémoire. 
 Voici donc la chose vraiment cool. 
 Les pointeurs nous permettent de passer des variables entre les fonctions. 
 Et en fait, passez des variables et n'en passez pas de copies. 
 Parce que si nous savons exactement où en mémoire trouver une variable, 
 nous n'avons pas besoin d'en faire une copie, nous pouvons simplement aller à cet endroit 
 et travailler avec cette variable. 
 Donc, en gros, les pointeurs font en quelque sorte un environnement informatique 
 beaucoup plus comme le monde réel, à droite. 
 >> Voici donc une analogie. 
 Disons que j'ai un cahier, à droite, et il est plein de notes. 
 Et j'aimerais que vous le mettiez à jour. 
 Vous êtes une fonction qui met à jour les notes, à droite. 
 Dans la façon dont nous avons travaillé jusqu'à présent, 

Turkish: 
 Eğer o oku takip edersem, beni bir yere götürür. 
 Ve o konum, benim örneğimde orada bulacağım şey, 
 yeşil renkli bir kutudur. 
 Bu bir tamsayı, bu adrese gidersem bulacağım. 
 Bir işaretçinin veri türü, 
 o bellek adresinde bulacaksınız. 
 İşte gerçekten harika bir şey. 
 İşaretçiler, değişkenleri işlevler arasında geçirmemize izin verir. 
 Ve aslında değişkenleri geçirin ve kopyalarını geçirmeyin. 
 Çünkü bir değişkeni nerede bulacağımızı tam olarak bilersek, 
 bir kopyasını çıkarmaya ihtiyacımız yok, sadece o yere gidebiliriz 
 ve bu değişkenle çalışın. 
 Yani aslında işaretçiler bir çeşit bilgisayar ortamı 
 gerçek dünyaya çok benziyor, değil mi? 
 >> İşte bir benzetme. 
 Diyelim ki bir defterim var, doğru ve notlarla dolu. 
 Ve güncellemenizi istiyorum. 
 Notları güncelleyen bir işlevsiniz, doğru. 
 Şu ana kadar çalıştığımız şekilde, ne 

Russian: 
 Если я последую за этой стрелой, это приведет меня к месту. 
 И это место, что я найду там в моем примере, 
 это коробка зеленого цвета. 
 Это целое число, вот что я найду, если пойду по этому адресу. 
 Тип данных указателя описывает, что 
 вы найдете по этому адресу памяти. 
 Так что вот действительно классная вещь. 
 Указатели позволяют нам передавать переменные между функциями. 
 И на самом деле передавать переменные, а не передавать их копии. 
 Потому что, если мы точно знаем, где в памяти найти переменную, 
 нам не нужно делать копию этого, мы можем просто пойти в это место 
 и работать с этой переменной. 
 Так что, по сути, указатели делают компьютерную среду 
 намного больше похоже на реальный мир, верно. 
 >> Так что вот аналогия. 
 Допустим, у меня есть блокнот, верно, и он полон заметок. 
 И я хотел бы, чтобы вы обновили его. 
 Вы - функция, которая обновляет заметки, верно. 
 По тому, как мы работали до сих пор, что 

Spanish: 
 Si sigo esa flecha, me llevará a una ubicación. 
 Y esa ubicación, lo que encontraré allí en mi ejemplo, 
 Es una caja de color verde. 
 Es un número entero, eso es lo que encontraré si voy a esa dirección. 
 El tipo de datos de un puntero describe qué 
 encontrará en esa dirección de memoria. 
 Sin embargo, aquí está lo realmente genial. 
 Los punteros nos permiten pasar variables entre funciones. 
 Y en realidad pasar variables y no pasar copias de ellas. 
 Porque si sabemos exactamente dónde en la memoria encontrar una variable, 
 no necesitamos hacer una copia, solo podemos ir a esa ubicación 
 y trabajar con esa variable. 
 Así que, en esencia, los punteros crean un entorno informático 
 mucho más parecido al mundo real, cierto. 
 >> Entonces aquí hay una analogía. 
 Digamos que tengo un cuaderno, correcto, y está lleno de notas. 
 Y me gustaría que lo actualizaras. 
 Eres una función que actualiza notas, correcto. 
 En la forma en que hemos estado trabajando hasta ahora, qué 

Arabic: 
 إذا اتبعت هذا السهم ، فسيقودني إلى موقع. 
 وهذا الموقع ، ما سأجده هناك في مثالي ، 
 مربع أخضر اللون. 
 إنه عدد صحيح ، هذا ما سأجده إذا ذهبت إلى هذا العنوان. 
 يصف نوع بيانات المؤشر ما 
 ستجد في عنوان الذاكرة ذلك. 
 إذن هذا هو الشيء الرائع حقًا. 
 تسمح لنا المؤشرات بتمرير المتغيرات بين الوظائف. 
 وفي الواقع تمرير المتغيرات وليس تمرير نسخ منها. 
 لأنه إذا علمنا بالضبط مكان وجود متغير في الذاكرة ، 
 لا نحتاج إلى عمل نسخة منه ، يمكننا فقط الذهاب إلى هذا الموقع 
 والعمل مع هذا المتغير. 
 لذا فإن المؤشرات تجعل من بيئة الكمبيوتر نوعًا ما 
 يشبه العالم الحقيقي ، صحيح. 
 >> إذن هذا تشبيه. 
 لنفترض أن لدي دفتر ملاحظات ، صحيح ، وهو مليء بالملاحظات. 
 وأود أن تقوم بتحديثه. 
 أنت وظيفة تقوم بتحديث الملاحظات ، صحيح. 
 بالطريقة التي كنا نعمل بها حتى الآن ، ماذا 

Chinese: 
如果我跟随那个箭头，它将带我到一个位置。 
在我的示例中可以找到的那个位置， 
是一个绿色的盒子。 
这是一个整数，如果我去那个地址，那就是我会发现的。 
指针的数据类型描述了什么
您会在该内存地址找到。 
所以这确实是很酷的事情。 
指针使我们能够在函数之间传递变量。 
并且实际上传递变量而不传递变量的副本。 
因为如果我们确切地知道在内存中哪里可以找到变量， 
我们不需要复制它，我们可以去那个地方
并使用该变量。 
因此，从本质上讲，指针可以构成计算机环境
更像现实世界，对。 
 >>所以这是一个比喻。 
假设我有一个笔记本，对了，上面满是笔记。 
我希望您进行更新。 
您是对笔记进行更新的功能。 
到目前为止，我们一直在努力

Japanese: 
あなたは私のノートを持っていき、あなたはコピーストアに行くでしょう
ノートブックのすべてのページのXeroxコピーを作成します。 
完了したら、ノートブックを机に置いておきます。 
私のノートにある古いものや間違っているものに取り消し線を引いて、 
その後、Xeroxページのスタックを私に返します
それはあなたがそれに加えた変更を加えた私のノートブックのレプリカです。 
その時点で、それは呼び出し側関数として、呼び出し側として私次第です。 
ノートを取り、私のノートブックに統合することにしました。 
したがって、ここには多くのステップが含まれています。 
ちょっと言えばいいのではないでしょうか
私のために私のノートを更新し、あなたに私のノートを手渡し、 
そして、あなたは物事を取り、文字通りそれらを取り消します
ノートブックのメモを更新します。 
そして、ノートを返してください。 
それは、ポインタが私たちにできることの一種です、 
彼らはこの環境を、私たちが実際にどのように運営しているかのようにしています。 
 >>大丈夫、それがポインタです。話しましょう
 Cでポインタがどのように機能するか、そしてポインタをどのように使用し始めることができるかについて。 

Portuguese: 
 acontece é que você vai pegar meu caderno, você vai para a loja de cópias, 
 você fará uma cópia Xerox de todas as páginas do notebook. 
 Você deixará meu caderno de volta na minha mesa quando terminar, 
 você vai atravessar coisas no meu caderno desatualizadas ou erradas, 
 e depois você me devolve a pilha de páginas da Xerox 
 essa é uma réplica do meu notebook com as alterações que você fez nele. 
 E nesse ponto, cabe a mim como a função de chamada, como o chamador, 
 decidir tomar suas anotações e integrá-las de volta ao meu caderno. 
 Portanto, existem muitas etapas envolvidas aqui, certo. 
 Como não seria melhor se eu apenas disser, ei, você pode 
 atualize meu notebook para mim, entregue-lhe meu notebook, 
 e você pega as coisas e as risca literalmente 
 e atualize minhas anotações no meu caderno. 
 E então me devolva meu caderno. 
 É o que os ponteiros nos permitem fazer, 
 eles tornam esse ambiente muito mais parecido com o modo como operamos na realidade. 
 >> Tudo bem, então é isso que um ponteiro é, vamos conversar 
 sobre como os ponteiros funcionam em C e como podemos começar a trabalhar com eles. 

Italian: 
 succede se prenderai il mio taccuino, andrai al negozio di copie, 
 realizzerai una copia Xerox di ogni pagina del notebook. 
 Lascerai il mio taccuino sulla mia scrivania quando hai finito, 
 andrai e cancellerai le cose sul mio taccuino che sono obsolete o sbagliate, 
 e poi mi restituirai la pila di pagine Xerox 
 quella è una replica del mio taccuino con le modifiche che hai apportato ad esso. 
 E a quel punto, dipende da me come funzione chiamante, come chiamante, 
 per decidere di prendere i tuoi appunti e integrarli nel mio taccuino. 
 Quindi ci sono molti passaggi coinvolti qui, giusto. 
 Come se non fosse meglio se dico solo, ehi, puoi 
 aggiorna il mio taccuino per me, passami il mio taccuino, 
 e prendi le cose e le cancelli letteralmente 
 e aggiorno le mie note sul mio taccuino. 
 E poi ridammi il mio taccuino. 
 È un po 'ciò che i puntatori ci consentono di fare, 
 rendono questo ambiente molto più simile al modo in cui operiamo nella realtà. 
 >> Va bene, ecco cos'è un puntatore, parliamo 
 su come funzionano i puntatori in C e su come possiamo iniziare a lavorare con loro. 

Hindi: 
 क्या आप मेरी नोटबुक लेंगे, आप कॉपी स्टोर पर जाएंगे, 
 आप नोटबुक के हर पृष्ठ की एक ज़ीरक्सा कॉपी करेंगे। 
 जब आप काम कर लेंगे, तो आप मेरी नोटबुक वापस मेरी मेज पर छोड़ देंगे, 
 तुम जाओ और मेरी नोटबुक में ऐसी चीज़ों को पार करोगे जो पुरानी हैं या गलत हैं, 
 और फिर तुम मेरे पास जेरोक्स पन्नों के ढेर के पास लौट जाओगे 
 मेरे द्वारा किए गए परिवर्तनों के साथ मेरी नोटबुक की प्रतिकृति है। 
 और उस बिंदु पर, यह कॉलिंग फ़ंक्शन के रूप में मेरे ऊपर है, फोन करने वाले के रूप में, 
 अपने नोट्स लेने और उन्हें वापस मेरी नोटबुक में एकीकृत करने का निर्णय लेने के लिए। 
 तो यहाँ बहुत सारे कदम शामिल हैं, ठीक है। 
 जैसे अगर मैं सिर्फ यह कहूं कि यह बेहतर नहीं होगा, तो आप कर सकते हैं 
 मेरे लिए मेरी नोटबुक अपडेट करें, आप मेरी नोटबुक को हाथ दें, 
 और आप चीजों को लेते हैं और सचमुच उन्हें पार करते हैं 
 और मेरी नोटबुक में मेरे नोट्स अपडेट करें। 
 और फिर मुझे अपनी नोटबुक वापस दें। 
 इस तरह के संकेत हमें क्या करने की अनुमति देते हैं, 
 वे इस माहौल को बहुत अधिक बनाते हैं जैसे हम वास्तविकता में कैसे काम करते हैं। 
 >> ठीक है तो यह है कि एक सूचक क्या है, चलो बात करते हैं 
 सी में पॉइंटर्स कैसे काम करते हैं, और हम उनके साथ कैसे काम करना शुरू कर सकते हैं। 

Korean: 
 당신은 내 노트를 가져갈 것이고, 당신은 복사 가게에 갈 것입니다. 
 노트북의 모든 페이지를 Xerox 사본으로 만듭니다. 
 작업이 끝나면 내 노트북을 책상에 다시 놓아두고 
 내 노트에 오래되었거나 잘못된 것들을 옮길 것입니다. 
 그런 다음 Xerox 페이지 스택을 나에게 다시 전달합니다. 
 변경 사항이있는 노트의 복제본입니다. 
 그 시점에서 그것은 호출자, 호출자, 나에게 달려 있습니다. 
 메모를하고 다시 내 노트에 통합하기로 결정했습니다. 
 여기에는 많은 단계가 있습니다. 
 내가 방금 말하면 나아지지 않을 것 같아 
 노트를 업데이트하고 노트를 건네주십시오. 
 그리고 당신은 물건을 가지고 말 그대로 그들을 밖으로 교차 
 노트에서 노트를 업데이트하십시오. 
 그리고 내 노트를 돌려줘 
 그것은 우리가 할 수있는 포인터의 종류입니다. 
 그들은이 환경을 우리가 실제로 운영하는 방식과 훨씬 비슷하게 만듭니다. 
 >> 알았어. 그래서 포인터가 무엇인지 이야기 해 봅시다. 
 C에서 포인터가 작동하는 방식과 포인터를 사용하는 방법에 대해 설명합니다. 

Spanish: 
 sucede es que tomarás mi cuaderno, irás a la tienda de copias, 
 Hará una copia de Xerox de cada página del cuaderno. 
 Dejarás mi cuaderno en mi escritorio cuando hayas terminado, 
 irás y tacharás cosas en mi cuaderno que están desactualizadas o mal, 
 y luego me pasarás la pila de páginas de Xerox 
 esa es una réplica de mi cuaderno con los cambios que le has hecho. 
 Y en ese punto, depende de mí como la función de llamada, como la persona que llama, 
 para decidir tomar sus notas e integrarlas nuevamente en mi cuaderno. 
 Entonces hay muchos pasos involucrados aquí, correcto. 
 ¿No sería mejor si solo dijera, oye, puedes? 
 actualizar mi cuaderno para mí, entregarle mi cuaderno, 
 y tomas cosas y literalmente las tachas 
 y actualizo mis notas en mi cuaderno. 
 Y luego devuélveme mi cuaderno. 
 Eso es lo que los punteros nos permiten hacer, 
 hacen que este entorno sea mucho más parecido a cómo operamos en la realidad. 
 >> Muy bien, eso es lo que es un puntero, hablemos 
 sobre cómo funcionan los punteros en C y cómo podemos comenzar a trabajar con ellos. 

German: 
 passiert, wenn du mein Notizbuch nimmst, gehst du in den Kopierladen, 
 Sie erstellen eine Xerox-Kopie jeder Seite des Notizbuchs. 
 Sie werden mein Notizbuch wieder auf meinem Schreibtisch liegen lassen, wenn Sie fertig sind. 
 Sie werden Dinge in meinem Notizbuch streichen, die veraltet oder falsch sind. 
 und dann geben Sie mir den Stapel Xerox-Seiten zurück 
 Das ist eine Nachbildung meines Notizbuchs mit den Änderungen, die Sie daran vorgenommen haben. 
 Und an diesem Punkt liegt es an mir als aufrufende Funktion, als Anrufer, 
 um zu entscheiden, Ihre Notizen zu machen und sie wieder in mein Notizbuch zu integrieren. 
 Hier sind also viele Schritte erforderlich, richtig. 
 Wäre es nicht besser, wenn ich nur sage, hey, kannst du? 
 Aktualisiere mein Notizbuch für mich, gib dir mein Notizbuch, 
 und du nimmst Dinge und streichst sie buchstäblich durch 
 und aktualisiere meine Notizen in meinem Notizbuch. 
 Und dann gib mir mein Notizbuch zurück. 
 Das ist es, was Zeiger uns erlauben, 
 Sie machen diese Umgebung viel ähnlicher, wie wir in der Realität arbeiten. 
 >> Also gut, das ist ein Zeiger, lass uns reden 
 darüber, wie Zeiger in C funktionieren und wie wir anfangen können, mit ihnen zu arbeiten. 

Chinese: 
碰巧是您要拿我的筆記本，然後去複印店， 
您將為筆記本的每一頁製作一份施樂複印件。 
完成後，您將把我的筆記本放回辦公桌上， 
您會去掉筆記本中過時或錯誤的內容， 
然後你會把一堆施樂頁面傳給我
那是我的筆記本的副本，其中包含您對其所做的更改。 
在那一點上，這取決於我作為調用函數，作為調用者， 
決定記筆記並將其重新整合到我的筆記本中。 
所以這裡涉及很多步驟。 
如果我只是說，嘿，會不會更好
為我更新我的筆記本，交給我我的筆記本， 
然後你拿東西，然後把它們劃掉
並在筆記本中更新我的筆記。 
然後把我的筆記本還給我。 
這就是指針允許我們做的事情， 
它們使這種環境更像我們在現實中的操作方式。 
 >>好吧，這就是指針，讓我們談談
關於指針在C中的工作方式，以及我們如何開始使用它們。 

Chinese: 
碰巧是您要拿我的笔记本，然后去复印店， 
您将为笔记本的每一页制作一份施乐复印件。 
完成后，您将把我的笔记本放回办公桌上， 
您会去掉笔记本中过时或错误的内容， 
然后你会把一堆施乐页面传给我
那是我的笔记本的副本，其中包含您对其所做的更改。 
在那一点上，这取决于我作为调用函数，作为调用者， 
决定记笔记并将其重新整合到我的笔记本中。 
所以这里涉及很多步骤。 
如果我只是说，嘿，会不会更好
为我更新我的笔记本，交给我我的笔记本， 
然后你拿东西，然后把它们划掉
并在笔记本中更新我的笔记。 
然后把我的笔记本还给我。 
这就是指针允许我们做的事情， 
它们使这种环境更像我们在现实中的操作方式。 
 >>好吧，这就是指针，让我们谈谈
关于指针在C中的工作方式，以及我们如何开始使用它们。 

English: 
happens is you will take my notebook, you'll go to the copy store,
you'll make a Xerox copy of every page of the notebook.
You'll leave my notebook back on my desk when you're done,
you'll go and cross out things in my notebook that are out of date or wrong,
and then you'll pass back to me the stack of Xerox pages
that is a replica of my notebook with the changes that you've made to it.
And at that point, it's up to me as the calling function, as the caller,
to decide to take your notes and integrate them back into my notebook.
So there's a lot of steps involved here, right.
Like wouldn't it be better if I just say, hey, can you
update my notebook for me, hand you my notebook,
and you take things and literally cross them out
and update my notes in my notebook.
And then give me my notebook back.
That's kind of what pointers allow us to do,
they make this environment a lot more like how we operate in reality.
>> All right so that's what a pointer is, let's talk
about how pointers work in C, and how we can start to work with them.

French: 
 arrive, vous prendrez mon cahier, vous irez au magasin de copie, 
 vous ferez une copie Xerox de chaque page du cahier. 
 Tu laisseras mon carnet sur mon bureau quand tu auras fini, 
 vous allez rayer des choses dans mon cahier qui sont périmées ou erronées, 
 et puis tu me passeras la pile de pages Xerox 
 c'est une réplique de mon cahier avec les modifications que vous y avez apportées. 
 Et à ce stade, c'est à moi en tant que fonction d'appel, en tant qu'appelant, 
 de décider de prendre vos notes et de les réintégrer dans mon cahier. 
 Donc, il y a beaucoup d'étapes impliquées ici, à droite. 
 Comme ça ne serait pas mieux si je dis juste, hé, pouvez-vous 
 mettre à jour mon cahier pour moi, vous remettre mon cahier, 
 et vous prenez les choses et les biffez littéralement 
 et mettre à jour mes notes dans mon cahier. 
 Et rendez-moi mon cahier. 
 C'est en quelque sorte ce que les pointeurs nous permettent de faire, 
 ils rendent cet environnement beaucoup plus semblable à la façon dont nous fonctionnons dans la réalité. 
 >> Très bien donc c'est ce qu'est un pointeur, parlons 
 sur la façon dont les pointeurs fonctionnent en C et comment nous pouvons commencer à travailler avec eux. 

Modern Greek (1453-): 
 συμβαίνει είναι ότι θα πάρετε το σημειωματάριό μου, θα πάτε στο κατάστημα αντίγραφο, 
 θα κάνετε ένα αντίγραφο Xerox κάθε σελίδας του φορητού υπολογιστή. 
 Θα αφήσετε το σημειωματάριό μου πίσω στο γραφείο μου όταν τελειώσετε, 
 θα πάτε και θα διαχωρίσετε τα πράγματα στο σημειωματάριό μου που είναι ξεπερασμένα ή λάθος, 
 και στη συνέχεια θα μου μεταβιβάσετε τη στοίβα των σελίδων της Xerox 
 αυτό είναι ένα αντίγραφο του σημειωματάριό μου με τις αλλαγές που έχετε κάνει σε αυτό. 
 Και σε αυτό το σημείο, εξαρτάται από μένα ως τη λειτουργία κλήσης, όπως ο καλών, 
 να αποφασίσετε να λάβετε τις σημειώσεις σας και να τις ενσωματώσετε ξανά στο σημειωματάριό μου. 
 Έτσι, υπάρχουν πολλά βήματα που εμπλέκονται εδώ, σωστά. 
 Όπως και να μην είναι καλύτερο να πω απλώς, έτσι μπορείτε 
 ενημερώστε το σημειωματάριό μου για μένα, 
 και παίρνετε τα πράγματα και κυριολεκτικά τα διασχίζετε 
 και ενημερώστε τις σημειώσεις μου στο σημειωματάριό μου. 
 Και έπειτα μου δώστε το σημειωματάριό μου πίσω. 
 Αυτό είναι που μας επιτρέπουν οι δείκτες, 
 κάνουν αυτό το περιβάλλον πολύ περισσότερο όπως το πώς λειτουργούμε στην πραγματικότητα. 
 >> Εντάξει, έτσι είναι αυτό που είναι ένας δείκτης, ας μιλήσουμε 
 για το πώς δουλεύουν οι δείκτες στο C και πώς μπορούμε να αρχίσουμε να δουλεύουμε μαζί τους. 

Arabic: 
 يحدث هو أن تأخذ دفتر الملاحظات الخاص بي ، ستذهب إلى متجر النسخ ، 
 ستقوم بعمل نسخة Xerox من كل صفحة من دفتر الملاحظات. 
 ستترك مفكرتي مرة أخرى على مكتبي عند الانتهاء ، 
 سوف تذهب وتشطب أشياء في دفتر ملاحظاتي قديمة أو خاطئة ، 
 ومن ثم ستعيد إليّ مجموعة صفحات زيروكس 
 هذه نسخة طبق الأصل من دفتر ملاحظاتي مع التغييرات التي أجريتها عليه. 
 وعند هذه النقطة ، الأمر متروك لي كوظيفة الاتصال ، كمتصل ، 
 لتقرر تدوين ملاحظاتك ودمجها مرة أخرى في دفتر ملاحظاتي. 
 لذا هناك الكثير من الخطوات هنا ، صحيح. 
 لن يكون من الأفضل أن أقول فقط ، هل يمكنك 
 تحديث دفتر الملاحظات لي ، تسليم لك دفتر الملاحظات ، 
 وأنت تأخذ الأشياء وتشطبها حرفيا 
 وتحديث ملاحظاتي في دفتر الملاحظات الخاص بي. 
 ثم أعيد لي دفتر ملاحظاتي. 
 هذا نوع ما تسمح لنا المؤشرات به ، 
 إنهم يجعلون هذه البيئة أشبه بكثير بكيفية عملنا في الواقع. 
 >> حسنًا ، هذا هو المؤشر ، لنتحدث 
 حول كيفية عمل المؤشرات في C ، وكيف يمكننا البدء في العمل معها. 

Indonesian: 
 yang terjadi adalah Anda akan mengambil buku catatan saya, Anda akan pergi ke toko salinan, 
 Anda akan membuat salinan Xerox dari setiap halaman notebook. 
 Anda akan meninggalkan buku catatan saya kembali di meja saya setelah selesai, 
 Anda akan pergi dan mencoret hal-hal di notebook saya yang ketinggalan zaman atau salah, 
 dan kemudian Anda akan memberikan tumpukan halaman Xerox kepada saya 
 itu adalah replika buku catatan saya dengan perubahan yang telah Anda lakukan padanya. 
 Dan pada titik itu, terserah saya sebagai fungsi panggilan, sebagai penelepon, 
 untuk memutuskan untuk mengambil catatan Anda dan mengintegrasikannya kembali ke notebook saya. 
 Jadi ada banyak langkah yang terlibat di sini, kan. 
 Seperti tidak akan lebih baik jika aku hanya mengatakan, hei, bisakah kamu 
 perbarui buku catatan saya untuk saya, berikan buku catatan saya, 
 dan Anda mengambil sesuatu dan benar-benar mencoretnya 
 dan perbarui catatan saya di buku catatan saya. 
 Dan kemudian berikan saya buku catatan saya kembali. 
 Itu semacam petunjuk apa yang memungkinkan kita lakukan, 
 mereka membuat lingkungan ini lebih seperti bagaimana kita beroperasi dalam kenyataan. 
 >> Baiklah jadi itulah pointernya, mari kita bicara 
 tentang bagaimana pointer bekerja di C, dan bagaimana kita bisa mulai bekerja dengannya. 

Turkish: 
 defterimi alacaksın, kopya mağazasına gideceksin, 
 not defterinin her sayfasının Xerox kopyasını oluşturacaksınız. 
 İşiniz bittiğinde not defterimi masamda bırakacaksınız, 
 dizüstü bilgisayarımdaki güncel olmayan veya yanlış şeyleri gidip geçeceksiniz, 
 ve sonra bana Xerox sayfa yığınını geri vereceksin 
 bu, not defterinde yaptığınız değişikliklerin bir kopyası. 
 Ve bu noktada, arama işlevi, arayan olarak, 
 notlarınızı alıp not defterime entegre etmeye karar vermek için. 
 Yani burada birçok adım var, değil mi? 
 Sadece söylesem daha iyi olmaz mıydı, hey, yapabilir misin 
 defterimi benim için güncelle, sana defterimi ver, 
 ve bir şeyleri alıp tam anlamıyla geçiyorsun 
 ve not defterimdeki notlarımı güncelle. 
 Ve sonra defterimi geri ver. 
 İşaretçilerin yapmasına izin veren şey budur, 
 bu ortamı gerçekte nasıl çalıştığımıza çok benzetiyorlar. 
 >> Pekala, bir işaretçi budur, konuşalım 
 C işaretçilerin nasıl çalıştığı ve onlarla nasıl çalışmaya başlayabileceğimiz hakkında. 

Dutch: 
 gebeurt, neem je mijn notitieboekje mee, dan ga je naar de kopieerwinkel, 
 u maakt een Xerox-kopie van elke pagina van de notebook. 
 Je legt mijn notitieboekje weer op mijn bureau als je klaar bent, 
 je gaat dingen in mijn notitieboek doorhalen die verouderd of verkeerd zijn, 
 en dan geef je mij de stapel Xerox-pagina's terug 
 dat is een replica van mijn notitieboek met de wijzigingen die je erin hebt aangebracht. 
 En op dat moment is het aan mij als de belfunctie, als de beller, 
 om te besluiten je aantekeningen te maken en ze weer in mijn notitieboek te integreren. 
 Er zijn hier dus veel stappen bij betrokken. 
 Zou het niet beter zijn als ik gewoon zeg, hé, kun je dat 
 update mijn notitieboek voor mij, geef me mijn notitieboek, 
 en je neemt dingen en schrapt ze letterlijk 
 en update mijn aantekeningen in mijn notitieboek. 
 En geef me dan mijn notitieboekje terug. 
 Dat is een soort van wat aanwijzers ons laten doen, 
 ze maken deze omgeving veel meer zoals hoe we in de praktijk werken. 
 >> Oké, dat is wat een aanwijzer is, laten we praten 
 over hoe pointers werken in C, en hoe we ermee kunnen gaan werken. 

Russian: 
 бывает, ты возьмешь мою записную книжку, пойдешь в копировальный магазин 
 Вы сделаете ксерокопию каждой страницы тетради. 
 Когда вы закончите, вы оставите мою записную книжку на моем столе, 
 ты пойдешь и вычеркнешь в моей записной книжке вещи, которые устарели или ошибочны, 
 и тогда ты вернешь мне стопку страниц Xerox 
 это копия моей записной книжки с изменениями, которые вы в нее внесли. 
 И в этот момент, это зависит от меня как вызывающей функции, как вызывающего, 
 принять решение взять ваши заметки и интегрировать их обратно в мою записную книжку. 
 Так что здесь много шагов, верно. 
 Как бы не было лучше, если бы я просто сказал, эй, можешь 
 обнови мой блокнот для меня, передай тебе мой блокнот, 
 и вы берете вещи и буквально вычеркиваете их 
 и обновить мои заметки в моем блокноте. 
 А потом верни мне мой блокнот. 
 Это то, что указатели позволяют нам делать, 
 они делают эту среду более похожей на то, как мы действуем в реальности. 
 >> Хорошо, так вот что такое указатель, давайте поговорим 
 о том, как работают указатели в C, и как мы можем начать с ними работать. 

Russian: 
 Так что в C есть очень простой указатель, называемый нулевым указателем. 
 Нулевой указатель указывает на ничто. 
 Это, вероятно, кажется, что это на самом деле не очень полезная вещь, 
 но, как мы увидим чуть позже, факт 
 что этот нулевой указатель существует на самом деле, может пригодиться. 
 И всякий раз, когда вы создаете указатель, и вы не устанавливаете его значение сразу 
 пример установки его значения сразу 
 будет пара слайдов назад, где я сказал, что рк равно & к, 
 pk получает адрес k, так как мы увидим, что это значит, 
 мы увидим, как это закодировать в ближайшее время - если мы не установим его значение на что-то 
 смысл сразу, вы должны всегда 
 установите указатель на ноль. 
 Вы должны установить это, чтобы указать ни на что. 
 >> Это очень отличается от просто оставить значение как есть 
 а затем объявив указатель и просто предполагая 
 это ноль, потому что это редко правда. 
 Таким образом, вы всегда должны установить значение указателя 
 к нулю, если вы не устанавливаете его значение на что-то значимое сразу. 
 Вы можете проверить, является ли значение указателя нулевым, используя оператор равенства 

English: 
So there's a very simple pointer in C called the null pointer.
The null pointer points to nothing.
This probably seems like it's actually not a very useful thing,
but as we'll see a little later on, the fact
that this null pointer exists actually really can come in handy.
And whenever you create a pointer, and you don't set its value immediately-
an example of setting its value immediately
will be a couple slides back where I said pk equals & k,
pk gets k's address, as we'll see what that means,
we'll see how to code that shortly- if we don't set its value to something
meaningful immediately, you should always
set your pointer to point to null.
You should set it to point to nothing.
>> That's very different than just leaving the value as it is
and then declaring a pointer and just assuming
it's null because that's rarely true.
So you should always set the value of a pointer
to null if you don't set its value to something meaningful immediately.
You can check whether a pointer's value is null using the equality operator

German: 
 Es gibt also einen sehr einfachen Zeiger in C, den Nullzeiger. 
 Der Nullzeiger zeigt auf nichts. 
 Dies scheint wahrscheinlich nicht sehr nützlich zu sein, 
 aber wie wir etwas später sehen werden, die Tatsache 
 dass dieser Nullzeiger tatsächlich existiert, kann wirklich nützlich sein. 
 Und wann immer Sie einen Zeiger erstellen und seinen Wert nicht sofort festlegen - 
 Ein Beispiel für die sofortige Einstellung des Werts 
 wird ein paar Folien zurück sein, wo ich sagte, pk ist gleich & k, 
 pk bekommt die Adresse von k, da wir sehen werden, was das bedeutet, 
 Wir werden in Kürze sehen, wie man das codiert - wenn wir seinen Wert nicht auf etwas setzen 
 Sinnvoll sofort sollten Sie immer 
 Setzen Sie Ihren Zeiger auf null. 
 Sie sollten es so einstellen, dass es auf nichts zeigt. 
 >> Das ist ganz anders, als nur den Wert so zu lassen, wie er ist 
 und dann einen Zeiger deklarieren und einfach annehmen 
 es ist null, weil das selten wahr ist. 
 Sie sollten also immer den Wert eines Zeigers festlegen 
 auf null setzen, wenn Sie den Wert nicht sofort auf etwas Sinnvolles setzen. 
 Mit dem Gleichheitsoperator können Sie überprüfen, ob der Wert eines Zeigers null ist 

Hindi: 
 इसलिए C में एक बहुत ही सरल पॉइंटर है जिसे null पॉइंटर कहा जाता है। 
 शून्य सूचक कुछ नहीं करने के लिए इंगित करता है। 
 यह शायद ऐसा लगता है कि यह वास्तव में बहुत उपयोगी चीज नहीं है, 
 लेकिन जैसा कि हम थोड़ी देर बाद देखेंगे, तथ्य 
 यह अशक्त सूचक वास्तव में वास्तव में काम में आ सकता है। 
 और जब भी आप एक पॉइंटर बनाते हैं, और आप तुरंत उसका मूल्य निर्धारित नहीं करते हैं- 
 इसके मूल्य को तुरंत स्थापित करने का एक उदाहरण 
 एक जोड़ी वापस स्लाइड होगा जहाँ मैंने कहा pk बराबरी और कश्मीर, 
 pk को k का पता मिलता है, क्योंकि हम देखेंगे कि इसका क्या मतलब है, 
 हम देखेंगे कि कैसे जल्द ही कोड किया जाए- अगर हम किसी चीज के लिए उसका मूल्य निर्धारित नहीं करते हैं 
 तुरंत सार्थक, आपको हमेशा चाहिए 
 अशक्त करने के लिए अपने सूचक सेट करें। 
 आपको इसे कुछ भी नहीं करने के लिए सेट करना चाहिए। 
 >> यह वैसा ही है जैसा कि मूल्य छोड़ने से बहुत अलग है 
 और फिर एक पॉइंटर घोषित करना और बस ग्रहण करना 
 यह अशक्त है क्योंकि यह शायद ही कभी सच है। 
 इसलिए आपको हमेशा एक पॉइंटर का मान सेट करना चाहिए 
 शून्य करने के लिए यदि आप इसके मूल्य को तुरंत सार्थक नहीं करते हैं। 
 आप यह देख सकते हैं कि समानता ऑपरेटर के उपयोग से पॉइंटर का मान शून्य है या नहीं 

Arabic: 
 لذلك هناك مؤشر بسيط للغاية في C يسمى المؤشر الفارغ. 
 يشير المؤشر الفارغ إلى لا شيء. 
 ربما يبدو هذا في الواقع أنه ليس مفيدًا جدًا ، 
 لكن كما سنرى لاحقًا ، الحقيقة 
 أن هذا المؤشر الخالي موجود بالفعل يمكن أن يكون مفيدًا. 
 وكلما قمت بإنشاء مؤشر ، ولم تقم بتعيين قيمته على الفور- 
 مثال على تحديد قيمته على الفور 
 سيكون هناك شريحتان للخلف حيث قلت pk يساوي & k ، 
 pk يحصل على عنوان k ، كما سنرى ماذا يعني ذلك ، 
 سنرى كيفية ترميز ذلك قريبًا - إذا لم نقم بتعيين قيمته لشيء ما 
 ذات مغزى على الفور ، يجب عليك دائمًا 
 اضبط المؤشر ليشير إلى قيمة خالية. 
 يجب عليك تعيينه للإشارة إلى لا شيء. 
 >> هذا مختلف تمامًا عن ترك القيمة كما هي 
 ثم يعلن عن المؤشر ويفترض فقط 
 لاغية لأن هذا نادرا ما يكون صحيحا. 
 لذلك يجب عليك دائمًا تعيين قيمة المؤشر 
 بالصفر إذا لم تقم بتعيين قيمته إلى شيء ذي معنى على الفور. 
 يمكنك التحقق مما إذا كانت قيمة المؤشر فارغة باستخدام عامل المساواة 

Dutch: 
 Er is dus een heel eenvoudige aanwijzer in C, de nulaanwijzer. 
 De null-aanwijzer verwijst naar niets. 
 Dit lijkt waarschijnlijk alsof het eigenlijk niet erg handig is, 
 maar zoals we later zullen zien, het feit 
 dat deze null-pointer bestaat, kan echt van pas komen. 
 En wanneer u een aanwijzer maakt en u stelt de waarde niet onmiddellijk in - 
 een voorbeeld van het onmiddellijk instellen van de waarde 
 zal een paar terugschuiven waar ik zei dat pk gelijk is aan & k, 
 pk krijgt het adres van k, zoals we zullen zien wat dat betekent, 
 we zullen zien hoe we dat binnenkort kunnen coderen - als we de waarde niet ergens op zetten 
 zinvol onmiddellijk, moet je altijd 
 stel uw aanwijzer in op nul. 
 Je moet het zo instellen dat het naar niets wijst. 
 >> Dat is heel anders dan de waarde gewoon te laten zoals die is 
 en dan een aanwijzer te verklaren en gewoon aan te nemen 
 het is null omdat dat zelden waar is. 
 U moet dus altijd de waarde van een aanwijzer instellen 
 naar null als u de waarde ervan niet onmiddellijk instelt op iets betekenisvols. 
 Met de gelijkheidsoperator kunt u controleren of de waarde van een aanwijzer null is 

Chinese: 
因此，C语言中有一个非常简单的指针，称为空指针。 
空指针指向什么。 
这似乎似乎并不是一件非常有用的事情， 
但是稍后我们会看到
这个空指针实际上确实可以派上用场。 
而且无论何时创建指针，都不会立即设置其值- 
立即设置其值的示例
将是几张幻灯片，我说pk等于＆k， 
 pk获取k的地址，因为我们将看到这意味着什么， 
我们将很快查看如何进行编码-如果我们不将其值设置为某种值
立即有意义，您应该始终
将您的指针指向空。 
您应该将其设置为不指向任何内容。 
 >>与保持原样的价值大不相同
然后声明一个指针，然后假设
它为null，因为很少如此。 
所以你应该总是设置一个指针的值
如果不立即将其值设置为有意义的值，则为null。 
您可以使用相等运算符检查指针的值是否为null 

Indonesian: 
 Jadi ada pointer yang sangat sederhana di C yang disebut null pointer. 
 Pointer nol menunjuk ke nol. 
 Ini mungkin sepertinya itu sebenarnya bukan hal yang sangat berguna, 
 tapi seperti yang akan kita lihat nanti, faktanya 
 bahwa null pointer ini ada sebenarnya sangat berguna. 
 Dan setiap kali Anda membuat pointer, dan Anda tidak menetapkan nilainya segera- 
 contoh pengaturan nilainya segera 
 akan ada beberapa slide kembali di mana aku berkata pk sama dengan & k, 
 pk mendapat alamat k, seperti yang akan kita lihat apa artinya, 
 kita akan melihat bagaimana cara membuat kode itu segera - jika kita tidak menetapkan nilainya untuk sesuatu 
 bermakna segera, Anda harus selalu 
 atur pointer Anda ke titik ke nol. 
 Anda harus mengaturnya agar tidak menunjukkan apa-apa. 
 >> Itu sangat berbeda dari hanya meninggalkan nilai apa adanya 
 dan kemudian mendeklarasikan pointer dan hanya mengasumsikan 
 itu nol karena itu jarang benar. 
 Jadi, Anda harus selalu menetapkan nilai pointer 
 ke null jika Anda tidak segera menetapkan nilainya ke sesuatu yang bermakna. 
 Anda dapat memeriksa apakah nilai pointer nol menggunakan operator kesetaraan 

Turkish: 
 C'de boş gösterici adı verilen çok basit bir işaretçi var. 
 Boş gösterici hiçbir şeye işaret etmez. 
 Bu muhtemelen çok yararlı bir şey değil gibi görünüyor, 
 ama biraz sonra göreceğimiz gibi, 
 bu boş göstergenin var olması gerçekten kullanışlı olabilir. 
 Ve bir işaretçi oluşturduğunuzda ve değerini hemen ayarlamazsanız 
 değerini hemen belirleme örneği 
 pk eşittir & k dediğim yerde bir çift slayt olacak, 
 pk k'nin adresini alır, bunun ne anlama geldiğini göreceğimizden, 
 kısaca kodlamayı göreceğiz - değerini bir şeye ayarlamazsak 
 hemen anlamlı, her zaman 
 işaretçinizi null değerine ayarlayın. 
 Hiçbir şeye işaret etmemelisiniz. 
 >> Bu değeri olduğu gibi bırakmaktan çok farklı 
 ve sonra bir işaretçi beyan edip sadece 
 boş çünkü bu nadiren doğrudur. 
 Bu yüzden her zaman bir işaretçinin değerini ayarlamanız gerekir 
 değerini anlamlı bir şeye hemen ayarlamazsanız null değerine ayarlayın. 
 Eşitlik operatörünü kullanarak bir işaretçinin değerinin boş olup olmadığını kontrol edebilirsiniz 

Italian: 
 Quindi c'è un puntatore molto semplice in C chiamato il puntatore null. 
 Il puntatore null indica nulla. 
 Questo probabilmente sembra che in realtà non sia una cosa molto utile, 
 ma come vedremo poco dopo, il fatto 
 che questo puntatore nullo esiste davvero può tornare utile. 
 E ogni volta che crei un puntatore e non imposti immediatamente il suo valore- 
 un esempio di impostazione immediata del suo valore 
 saranno un paio di diapositive dove ho detto che pk è uguale a & k, 
 pk ottiene l'indirizzo di k, poiché vedremo cosa significa, 
 vedremo come codificarlo a breve, se non impostiamo il suo valore su qualcosa 
 significativo immediatamente, dovresti sempre 
 imposta il puntatore su punto su null. 
 Dovresti impostarlo in modo che non punti a nulla. 
 >> È molto diverso dal lasciare il valore così com'è 
 e poi dichiarando un puntatore e solo assumendo 
 è nullo perché raramente è vero. 
 Quindi dovresti sempre impostare il valore di un puntatore 
 su null se non si imposta immediatamente il valore su qualcosa di significativo. 
 È possibile verificare se il valore di un puntatore è null utilizzando l'operatore di uguaglianza 

French: 
 Il y a donc un pointeur très simple en C appelé pointeur nul. 
 Le pointeur nul ne pointe vers rien. 
 Cela semble probablement que ce n'est pas vraiment une chose très utile, 
 mais comme nous le verrons un peu plus tard, le fait 
 que ce pointeur nul existe réellement peut vraiment être utile. 
 Et chaque fois que vous créez un pointeur, et que vous ne définissez pas sa valeur immédiatement- 
 un exemple de définition immédiate de sa valeur 
 sera quelques diapositives de retour où je dis pk est égal à & k, 
 pk obtient l'adresse de k, comme nous allons voir ce que cela signifie, 
 nous verrons comment coder cela sous peu - si nous ne définissons pas sa valeur sur quelque chose 
 significatif immédiatement, vous devez toujours 
 définissez votre pointeur pour pointer sur null. 
 Vous devez le régler pour qu'il ne pointe vers rien. 
 >> C'est très différent que de laisser la valeur telle quelle 
 puis déclarer un pointeur et supposer simplement 
 c'est nul parce que c'est rarement vrai. 
 Vous devez donc toujours définir la valeur d'un pointeur 
 à null si vous ne définissez pas sa valeur sur quelque chose de significatif immédiatement. 
 Vous pouvez vérifier si la valeur d'un pointeur est nulle en utilisant l'opérateur d'égalité 

Spanish: 
 Entonces, hay un puntero muy simple en C llamado puntero nulo. 
 El puntero nulo apunta a nada. 
 Esto probablemente parece que en realidad no es algo muy útil, 
 pero como veremos un poco más adelante, el hecho 
 que este puntero nulo exista realmente puede ser útil. 
 Y cada vez que crea un puntero, y no establece su valor inmediatamente, 
 un ejemplo de establecer su valor de inmediato 
 habrá un par de diapositivas donde dije que pk es igual a & k, 
 pk obtiene la dirección de k, como veremos lo que eso significa, 
 veremos cómo codificar eso en breve, si no establecemos su valor en algo 
 significativo de inmediato, siempre debes 
 configura el puntero para que apunte a nulo. 
 Debes configurarlo para que apunte a nada. 
 >> Eso es muy diferente a dejar el valor tal como está 
 y luego declarando un puntero y simplemente asumiendo 
 es nulo porque eso rara vez es cierto. 
 Por lo tanto, siempre debe establecer el valor de un puntero 
 nulo si no establece su valor en algo significativo de inmediato. 
 Puede verificar si el valor de un puntero es nulo utilizando el operador de igualdad 

Chinese: 
因此，C語言中有一個非常簡單的指針，稱為空指針。 
空指針指向什麼。 
這似乎似乎並不是一件非常有用的事情， 
但是稍後我們會看到
這個空指針實際上確實可以派上用場。 
而且無論何時創建指針，都不會立即設置其值- 
立即設置其值的示例
將是幾張幻燈片，我說pk等於＆k， 
 pk獲取k的地址，因為我們將看到這意味著什麼， 
我們將很快查看如何進行編碼-如果我們不將其值設置為某種值
立即有意義，您應該始終
將您的指針指向空。 
您應該將其設置為不指向任何內容。 
 >>與保持原樣的價值大不相同
然後聲明一個指針，然後假設
它為null，因為很少如此。 
所以你應該總是設置一個指針的值
如果不立即將其值設置為有意義的值，則為null。 
您可以使用相等運算符檢查指針的值是否為null 

Modern Greek (1453-): 
 Έτσι, υπάρχει ένας πολύ απλός δείκτης στον C που ονομάζεται μηδενικός δείκτης. 
 Ο μηδενικός δείκτης δεν δείχνει τίποτα. 
 Αυτό μάλλον φαίνεται σαν να μην είναι πραγματικά πολύ χρήσιμο πράγμα, 
 αλλά όπως θα δούμε λίγο αργότερα, το γεγονός 
 ότι αυτός ο μηδενικός δείκτης υπάρχει πραγματικά πραγματικά μπορεί να έρθει σε πρακτικό. 
 Και κάθε φορά που δημιουργείτε έναν δείκτη και δεν ρυθμίζετε αμέσως την τιμή του - 
 ένα παράδειγμα καθορισμού της αξίας του αμέσως 
 θα είναι ένα ζευγάρι διαφάνειες πίσω όπου είπα pk ισούται & k, 
 pk παίρνει τη διεύθυνση k, καθώς θα δούμε τι σημαίνει αυτό, 
 θα δούμε πώς να το κωδικοποιήσουμε αυτό σύντομα- αν δεν θέσουμε την αξία του σε κάτι 
 το νόημα αμέσως, θα πρέπει πάντα 
 ορίστε το δείκτη σας να δείχνει μηδενικό. 
 Πρέπει να το ορίσετε ώστε να μην δείχνει τίποτα. 
 >> Αυτό είναι πολύ διαφορετικό από το να αφήνεις την αξία όπως είναι 
 και στη συνέχεια δηλώνοντας έναν δείκτη και υποθέτοντας απλά 
 είναι null επειδή αυτό είναι σπάνια αλήθεια. 
 Επομένως, πρέπει πάντα να ορίσετε την τιμή ενός δείκτη 
 να μηδενίσετε αν δεν καθορίσετε την αξία του σε κάτι ουσιαστικό αμέσως. 
 Μπορείτε να ελέγξετε αν η τιμή ενός δείκτη είναι μηδενική χρησιμοποιώντας τον χειριστή ισότητας 

Portuguese: 
 Portanto, há um ponteiro muito simples em C chamado ponteiro nulo. 
 O ponteiro nulo não aponta para nada. 
 Provavelmente parece que não é realmente uma coisa muito útil, 
 mas como veremos mais adiante, o fato 
 O fato de esse ponteiro nulo existir realmente pode ser útil. 
 E sempre que você cria um ponteiro e não define seu valor imediatamente, 
 um exemplo de configuração de seu valor imediatamente 
 haverá alguns slides de volta onde eu disse pk é igual a k, 
 pk obtém o endereço de k, como veremos o que isso significa, 
 veremos como codificar isso em breve - se não definirmos seu valor como algo 
 significativo imediatamente, você deve sempre 
 defina seu ponteiro para apontar para nulo. 
 Você deve configurá-lo para apontar para nada. 
 >> Isso é muito diferente do que apenas deixar o valor como está 
 e depois declarar um ponteiro e apenas assumindo 
 é nulo porque isso raramente é verdade. 
 Portanto, você sempre deve definir o valor de um ponteiro 
 para null se você não definir seu valor para algo significativo imediatamente. 
 Você pode verificar se o valor de um ponteiro é nulo usando o operador de igualdade 

Japanese: 
したがって、Cにはnullポインターと呼ばれる非常に単純なポインターがあります。 
 nullポインタは何も指していない。 
これはおそらく実際にはあまり役に立たないようです。 
後で見るように、事実
このnullポインターが実際に存在することは、実際に役立ちます。 
そして、ポインタを作成し、その値をすぐに設定しない場合は常に、 
その値をすぐに設定する例
 pkが＆kと言ったところでスライドが2枚戻ります。 
 pkはkのアドレスを取得します。 
すぐにコード化する方法を確認します。値を設定しない場合は
すぐに意味があり、常に
ポインタをnullを指すように設定します。 
何も指さないように設定する必要があります。 
 >>値をそのままにするのとはかなり異なります
ポインタを宣言して、 
それはめったに本当ではないのでそれはnullです。 
したがって、常にポインタの値を設定する必要があります
すぐに意味のある値に値を設定しない場合はnullに。 
等価演算子を使用して、ポインタの値がnullかどうかを確認できます

Korean: 
 따라서 C에는 널 포인터라는 매우 간단한 포인터가 있습니다. 
 널 포인터는 아무것도 가리 키지 않습니다. 
 아마도 실제로는 그다지 유용하지 않은 것 같습니다. 
 하지만 나중에 보 겠지만 사실 
 이 널 포인터가 실제로 존재한다는 것은 실제로 유용 할 수 있습니다. 
 그리고 포인터를 만들 때마다 값을 즉시 설정하지 않습니다. 
 값을 즉시 설정하는 예 
 내가 pk equals & k라고 말한 곳에서 몇 개의 슬라이드가 다시 나타납니다. 
 pk는 k의 주소를 얻습니다. 
 값을 무언가로 설정하지 않으면 코드를 작성하는 방법을 곧 알게 될 것입니다. 
 의미있는 즉시, 당신은 항상해야합니다 
 포인터가 널을 가리 키도록 설정하십시오. 
 아무것도 가리 키지 않도록 설정해야합니다. 
 >> 값을 그대로 두는 것과는 매우 다릅니다 
 그런 다음 포인터를 선언하고 가정합니다. 
 거의 사실이 아니기 때문에 null입니다. 
 따라서 항상 포인터 값을 설정해야합니다 
 값을 즉시 의미있는 값으로 설정하지 않으면 null이됩니다. 
 항등 연산자를 사용하여 포인터 값이 null인지 확인할 수 있습니다 

Dutch: 
 (==), net zoals je alle integerwaarden of tekenwaarden vergelijkt met (==) 
 ook. 
 Het is een speciaal soort constante waarde die u kunt gebruiken om te testen. 
 Dat was dus een heel simpele aanwijzer, de nul-aanwijzer. 
 Een andere manier om een ​​aanwijzer te maken, is door te extraheren 
 het adres van een variabele die je al hebt gemaakt, 
 en u doet dit met de extractie van het & operator-adres. 
 Wat we eerder al zagen in het eerste diagramvoorbeeld dat ik liet zien. 
 Dus als x een variabele is die we al hebben gemaakt van type integer, 
 dan is & x een pointer naar een geheel getal. 
 & x is- onthoud, & gaat het adres van het ding aan de rechterkant extraheren. 
 En aangezien een pointer slechts een adres is, is & x een pointer naar een geheel getal 
 wiens waarde is waar in het geheugen x leeft. 
 Het is het adres van x. 
 Dus & x is het adres van x. 
 Laten we nog een stap verder gaan en ergens verbinding mee maken 
 Ik zinspeelde in een eerdere video. 

Turkish: 
 (==), tıpkı (==) tuşlarını kullanarak tam sayı değerlerini veya karakter değerlerini karşılaştırdığınız gibi 
 de. 
 Test etmek için kullanabileceğiniz özel bir sabit değer türüdür. 
 Bu çok basit bir işaretçi, boş gösterici. 
 İşaretçi oluşturmanın başka bir yolu da 
 önceden oluşturduğunuz bir değişkenin adresi, 
 bunu & operatörü adres çıkarma işlemini kullanarak yapabilirsiniz. 
 Daha önce gördüğüm ilk diyagram örneğinde daha önce gördüğümüz. 
 Eğer x zaten integer türünde oluşturduğumuz bir değişkense, 
 & x bir tamsayının göstergesidir. 
 & x is- unutmayın, ve sağdaki şeyin adresini çıkaracaktır. 
 Ve bir işaretçi sadece bir adres olduğundan, & x bir tamsayıya işaretçi 
 değeri x hafızasında olan yerdir. 
 X'in adresi. 
 Yani & x, x'in adresidir. 
 Bunu bir adım daha ileri götürelim ve bir şeye bağlanalım 
 Önceki bir videoda bahsetmiştim. 

Modern Greek (1453-): 
 (==), ακριβώς όπως συγκρίνετε οποιεσδήποτε ακέραιες τιμές ή τιμές χαρακτήρων χρησιμοποιώντας (==) 
 επισης. 
 Είναι ένα ειδικό είδος σταθερής τιμής που μπορείτε να χρησιμοποιήσετε για να δοκιμάσετε. 
 Έτσι ήταν ένας πολύ απλός δείκτης, ο μηδενικός δείκτης. 
 Ένας άλλος τρόπος για να δημιουργήσετε ένα δείκτη είναι να εξαγάγετε 
 τη διεύθυνση μιας μεταβλητής που έχετε ήδη δημιουργήσει, 
 και το κάνετε αυτό χρησιμοποιώντας την εξαγωγή διεύθυνσης & χειριστή. 
 Αυτό που έχουμε ήδη δει στο παρελθόν στο παράδειγμα του πρώτου διαγράμματος που έδειξα. 
 Επομένως, αν το x είναι μια μεταβλητή που έχουμε ήδη δημιουργήσει από τον ακέραιο τύπο, 
 τότε το & x είναι ένας δείκτης σε έναν ακέραιο αριθμό. 
 & x είναι - θυμηθείτε, & πρόκειται να εξαγάγει τη διεύθυνση του πράγματος στα δεξιά. 
 Και επειδή ένας δείκτης είναι απλά μια διεύθυνση, από το & x είναι ένας δείκτης σε έναν ακέραιο αριθμό 
 της οποίας η αξία είναι εκείνη που ζει στη μνήμη x. 
 Είναι η διεύθυνση του x. 
 Έτσι & x είναι η διεύθυνση του x. 
 Ας πάρουμε αυτό το βήμα παραπέρα και να συνδεθούμε με κάτι 
 Αναφέρθηκα σε ένα προηγούμενο βίντεο. 

English: 
(==), just like you compare any integer values or character values using (==)
as well.
It's a special sort of constant value that you can use to test.
So that was a very simple pointer, the null pointer.
Another way to create a pointer is to extract
the address of a variable you've already created,
and you do this using the & operator address extraction.
Which we've already seen previously in the first diagram example I showed.
So if x is a variable that we've already created of type integer,
then &x is a pointer to an integer.
&x is- remember, & is going to extract the address of the thing on the right.
And since a pointer is just an address, than &x is a pointer to an integer
whose value is where in memory x lives.
It's x's address.
So &x is the address of x.
Let's take this one step further and connect to something
I alluded to in a prior video.

German: 
 (==), genau wie Sie alle Ganzzahl- oder Zeichenwerte mit (==) vergleichen. 
 auch. 
 Es ist eine spezielle Art von konstantem Wert, den Sie zum Testen verwenden können. 
 Das war also ein sehr einfacher Zeiger, der Nullzeiger. 
 Eine andere Möglichkeit, einen Zeiger zu erstellen, ist das Extrahieren 
 die Adresse einer Variablen, die Sie bereits erstellt haben, 
 und Sie tun dies mit der & Operator-Adressenextraktion. 
 Was wir bereits im ersten Diagrammbeispiel gesehen haben, das ich gezeigt habe. 
 Wenn also x eine Variable ist, die wir bereits vom Typ Integer erstellt haben, 
 dann ist & x ein Zeiger auf eine ganze Zahl. 
 & x ist - denken Sie daran, & wird die Adresse der Sache auf der rechten Seite extrahieren. 
 Und da ein Zeiger nur eine Adresse ist, ist & x ein Zeiger auf eine ganze Zahl 
 dessen Wert ist, wo im Speicher x lebt. 
 Es ist die Adresse von x. 
 Also ist & x die Adresse von x. 
 Gehen wir noch einen Schritt weiter und verbinden uns mit etwas 
 Ich habe in einem früheren Video darauf hingewiesen. 

Indonesian: 
 (==), sama seperti Anda membandingkan nilai integer atau nilai karakter menggunakan (==) 
 demikian juga. 
 Ini semacam nilai konstan khusus yang dapat Anda gunakan untuk menguji. 
 Jadi itu adalah pointer yang sangat sederhana, pointer nol. 
 Cara lain untuk membuat pointer adalah mengekstrak 
 alamat variabel yang sudah Anda buat, 
 dan Anda melakukan ini menggunakan ekstraksi alamat & operator. 
 Yang telah kita lihat sebelumnya pada contoh diagram pertama yang saya tunjukkan. 
 Jadi jika x adalah variabel yang telah kita buat dari tipe integer, 
 maka & x adalah pointer ke integer. 
 & x adalah- ingat, & akan mengekstrak alamat benda di sebelah kanan. 
 Dan karena sebuah pointer hanyalah sebuah alamat, maka & x adalah sebuah pointer ke sebuah integer 
 yang nilainya adalah tempat di memori x tinggal. 
 Ini alamat x. 
 Jadi & x adalah alamat x. 
 Mari kita selangkah lebih maju dan terhubung dengan sesuatu 
 Saya singgung di video sebelumnya. 

Portuguese: 
 (==), assim como você compara qualquer valor inteiro ou valor de caractere usando (==) 
 também. 
 É um tipo especial de valor constante que você pode usar para testar. 
 Então esse era um ponteiro muito simples, o ponteiro nulo. 
 Outra maneira de criar um ponteiro é extrair 
 o endereço de uma variável que você já criou, 
 e você faz isso usando a extração de endereço do operador &. 
 O que já vimos anteriormente no primeiro exemplo de diagrama que mostrei. 
 Portanto, se x é uma variável que já criamos do tipo número inteiro, 
 então & x é um ponteiro para um número inteiro. 
 & x é- lembre-se, & vai extrair o endereço da coisa à direita. 
 E como um ponteiro é apenas um endereço, então & x é um ponteiro para um número inteiro 
 cujo valor é onde na memória x vive. 
 É o endereço do x. 
 Então, x é o endereço de x. 
 Vamos dar um passo adiante e nos conectar a algo 
 Eu aludi em um vídeo anterior. 

Chinese: 
 （==），就像您使用（==）比較任何整數值或字符值一樣
也一樣
這是一種特殊的常量值，可以用來測試。 
因此，這是一個非常簡單的指針，即空指針。 
創建指針的另一種方法是提取
您已經創建的變量的地址， 
然後使用＆運算符地址提取進行操作。 
我們在前面顯示的第一個圖表示例中已經看到了。 
因此，如果x是我們已經創建的整數類型變量， 
然後＆x是指向整數的指針。 
 ＆x是-記住，＆將提取右邊的東西的地址。 
而且由於指針只是一個地址，所以＆x是指向整數的指針
其值就是x在內存中的位置。 
是x的地址。 
因此＆x是x的地址。 
讓我們更進一步，連接到某個東西
我在之前的視頻中提到過。 

Chinese: 
 （==），就像您使用（==）比较任何整数值或字符值一样
也一样
这是一种特殊的常量值，可以用来测试。 
因此，这是一个非常简单的指针，即空指针。 
创建指针的另一种方法是提取
您已经创建的变量的地址， 
然后使用＆运算符地址提取进行操作。 
我们在前面显示的第一个图表示例中已经看到了。 
因此，如果x是我们已经创建的整数类型变量， 
然后＆x是指向整数的指针。 
 ＆x是-记住，＆将提取右边的东西的地址。 
而且由于指针只是一个地址，所以＆x是指向整数的指针
其值就是x在内存中的位置。 
是x的地址。 
因此＆x是x的地址。 
让我们更进一步，连接到某个东西
我在之前的视频中提到过。 

Korean: 
 (==)를 사용하여 정수 값 또는 문자 값을 비교하는 것처럼 (==) 
 게다가. 
 테스트에 사용할 수있는 특별한 종류의 상수 값입니다. 
 그래서 그것은 매우 간단한 포인터, 널 포인터였습니다. 
 포인터를 만드는 또 다른 방법은 추출하는 것입니다 
 이미 만든 변수의 주소 
 & 연산자 주소 추출을 사용하여이 작업을 수행합니다. 
 우리가 이미 보여준 첫 번째 다이어그램 예제에서 이미 보았습니다. 
 x가 정수형으로 이미 만든 변수라면 
 & x는 정수에 대한 포인터입니다. 
 & x는 기억하고 &는 오른쪽에있는 주소를 추출 할 것입니다. 
 그리고 포인터는 단지 주소이기 때문에 & x는 정수에 대한 포인터보다 
 그 가치는 메모리 x가 사는 곳입니다. 
 x의 주소입니다. 
 따라서 & x는 x의 주소입니다. 
 한 걸음 더 나아가서 무언가에 연결합시다 
 나는 이전 비디오에서 언급했다. 

Russian: 
 (==), так же, как вы сравниваете любые целочисленные значения или значения символов, используя (==) 
 также. 
 Это особый вид постоянного значения, которое вы можете использовать для проверки. 
 Так что это был очень простой указатель, нулевой указатель. 
 Другой способ создать указатель - извлечь 
 адрес переменной, которую вы уже создали, 
 и вы делаете это, используя & оператор извлечения адреса. 
 Что мы уже видели ранее в первом примере диаграммы, который я показал. 
 Так что, если x - это переменная, которую мы уже создали, с типом integer, 
 тогда & x - указатель на целое число. 
 & x is- запомнить, & собирается извлечь адрес этой вещи справа. 
 И поскольку указатель является просто адресом, то & x является указателем на целое число 
 чье значение где в памяти х живет. 
 Это адрес Х 
 Так & х это адрес х. 
 Давайте сделаем еще один шаг и подключимся к чему-то 
 Я упоминал в предыдущем видео. 

Italian: 
 (==), proprio come si confronta qualsiasi valore intero o valore di carattere utilizzando (==) 
 anche. 
 È un tipo speciale di valore costante che puoi usare per testare. 
 Quindi quello era un puntatore molto semplice, il puntatore null. 
 Un altro modo per creare un puntatore è estrarre 
 l'indirizzo di una variabile che hai già creato, 
 e lo fai usando l'estrazione dell'indirizzo & dell'operatore. 
 Che abbiamo già visto in precedenza nel primo esempio di diagramma che ho mostrato. 
 Quindi se x è una variabile che abbiamo già creato di tipo intero, 
 allora & x è un puntatore a un numero intero. 
 & x è- ricorda, e sta per estrarre l'indirizzo della cosa sulla destra. 
 E poiché un puntatore è solo un indirizzo, allora & x è un puntatore a un numero intero 
 il cui valore è dove in memoria x vive. 
 È l'indirizzo di x. 
 Quindi & x è l'indirizzo di x. 
 Facciamo un ulteriore passo avanti e connettiamoci a qualcosa 
 Ho accennato in un video precedente. 

Arabic: 
 (==) ، تمامًا كما تقارن أي قيم صحيحة أو قيم أحرف باستخدام (==) 
 كذلك. 
 إنه نوع خاص من القيمة الثابتة التي يمكنك استخدامها للاختبار. 
 لذلك كان هذا مؤشرًا بسيطًا جدًا ، وهو المؤشر الفارغ. 
 طريقة أخرى لإنشاء مؤشر هي الاستخراج 
 عنوان متغير قمت بإنشائه بالفعل ، 
 وتقوم بذلك باستخدام استخراج عنوان عامل التشغيل. 
 الذي رأيناه سابقًا في المثال الأول من الرسم التخطيطي الذي عرضته. 
 لذا إذا كان x متغير أنشأناه بالفعل من النوع الصحيح ، 
 ثم & x مؤشر إلى عدد صحيح. 
 & x is- تذكر ، & سيستخرج عنوان الشيء الموجود على اليمين. 
 وبما أن المؤشر مجرد عنوان ، فإن & x هو مؤشر إلى عدد صحيح 
 الذي قيمته هي المكان الذي تعيش فيه الذاكرة. 
 إنه عنوان x. 
 لذا فإن & x هو عنوان x. 
 دعنا نخطو خطوة أخرى ونتواصل مع شيء ما 
 لقد أشرت إليها في فيديو سابق. 

French: 
 (==), tout comme vous comparez des valeurs entières ou des caractères en utilisant (==) 
 ainsi que. 
 C'est une sorte spéciale de valeur constante que vous pouvez utiliser pour tester. 
 C'était donc un pointeur très simple, le pointeur nul. 
 Une autre façon de créer un pointeur est d'extraire 
 l'adresse d'une variable que vous avez déjà créée, 
 et vous faites cela en utilisant l'extraction d'adresse opérateur. 
 Ce que nous avons déjà vu précédemment dans le premier exemple de diagramme que j'ai montré. 
 Donc, si x est une variable que nous avons déjà créée de type entier, 
 alors & x est un pointeur sur un entier. 
 & x est - rappelez-vous, & va extraire l'adresse de la chose à droite. 
 Et comme un pointeur n'est qu'une adresse, alors & x est un pointeur sur un entier 
 dont la valeur est où en mémoire x vit. 
 C'est l'adresse de x. 
 So & x est l'adresse de x. 
 Allons plus loin et connectons-nous à quelque chose 
 J'y ai fait allusion dans une vidéo précédente. 

Japanese: 
 （==）、（==）を使用して整数値または文字値を比較するのと同じように
同じように。 
これは、テストに使用できる特別な種類の定数値です。 
つまり、これは非常に単純なポインター、nullポインターでした。 
ポインタを作成する別の方法は、抽出することです
すでに作成した変数のアドレス
 ＆演算子アドレス抽出を使用してこれを行います。 
これは、最初に示した最初の図の例ですでに見たものです。 
したがって、xが整数型の変数を既に作成している場合、 
 ＆xは整数へのポインタです。 
 ＆xは-覚えておいて、＆は右側にあるもののアドレスを抽出します。 
そして、ポインタは単なるアドレスなので、＆xは整数へのポインタです
その値は、メモリxが存在する場所です。 
 xのアドレスです。 
したがって、＆xはxのアドレスです。 
これをさらに一歩進めて何かに接続しましょう
以前のビデオで触れました。 

Hindi: 
 (==), जैसे आप किसी पूर्णांक मान या वर्ण मान की तुलना करते हैं (==) 
 भी। 
 यह एक विशेष प्रकार का निरंतर मूल्य है जिसे आप परीक्षण करने के लिए उपयोग कर सकते हैं। 
 तो यह एक बहुत ही सरल सूचक था, अशक्त सूचक। 
 पॉइंटर बनाने का एक और तरीका है एक्स्ट्रेक्ट 
 आपके द्वारा पहले से बनाए गए एक चर का पता 
 और आप इसे & ऑपरेटर एड्रेस निष्कर्षण का उपयोग करके करते हैं। 
 जो हमने पहले ही पहले आरेख उदाहरण में दिखाया है जो मैंने दिखाया था। 
 तो अगर x एक वैरिएबल है जो हमने पहले ही टाइप पूर्णांक से बनाया है, 
 तब और x एक पूर्णांक के लिए एक संकेतक है। 
 & x याद है- और दाईं ओर स्थित वस्तु का पता निकालने वाला है। 
 और चूँकि एक पॉइंटर केवल एक पता है, और x एक पूर्णांक के लिए एक पॉइंटर है 
 जिसका मान मेमोरी x में रहता है। 
 यह x का पता है। 
 तो & x, x का पता है। 
 चलिए इस एक कदम को आगे बढ़ाते हैं और किसी चीज़ से जुड़ते हैं 
 मैं एक पूर्व वीडियो में alluded। 

Spanish: 
 (==), al igual que compara cualquier valor entero o valor de carácter usando (==) 
 también. 
 Es un tipo especial de valor constante que puede usar para probar. 
 Entonces ese era un puntero muy simple, el puntero nulo. 
 Otra forma de crear un puntero es extraer 
 la dirección de una variable que ya has creado, 
 y lo hace utilizando la extracción de dirección del operador &. 
 Lo que ya hemos visto anteriormente en el primer ejemplo de diagrama que mostré. 
 Entonces, si x es una variable que ya hemos creado de tipo entero, 
 entonces & x es un puntero a un entero. 
 & x es- recuerda, y va a extraer la dirección de la cosa a la derecha. 
 Y dado que un puntero es solo una dirección, entonces & x es un puntero a un entero 
 cuyo valor es donde en la memoria vive x. 
 Es la dirección de x. 
 Entonces & x es la dirección de x. 
 Avancemos un paso más y conectemos a algo 
 Aludí en un video anterior. 

Spanish: 
 Si arr es un conjunto de dobles, entonces & arr corchete i es un puntero 
 a un doble. 
 OKAY. 
 arr corchete cuadrado i, si arr es un conjunto de dobles, 
 entonces arr corchete i es el elemento i-ésimo de esa matriz, 
 y & arr corchetes i es donde en memoria existe el i-ésimo elemento de arr. 
 >> Entonces, ¿cuál es la implicación aquí? 
 Un nombre de matriz, la implicación de todo esto, 
 es que el nombre de una matriz es en sí mismo un puntero. 
 Has estado trabajando con punteros todo el tiempo 
 cada vez que has usado una matriz. 
 Recuerde del ejemplo en alcance variable, 
 cerca del final del video presento un ejemplo donde tenemos una función 
 llamado set int y una función llamada set array. 

Turkish: 
 Eğer arr çiftler dizisiyse, & arr köşeli ayraç i bir işaretçi 
 bir çifte. 
 TAMAM. 
 arr köşeli ayraç i, eğer arr iki katına çıkarsa, 
 o zaman arr köşeli ayraç i bu dizinin i-th öğesidir, 
 ve & arr köşeli ayraç, bellekte arr'ın i-öğesinin bulunduğu yerdir. 
 >> Peki, buradaki sonuç nedir? 
 Bir dizinin adı, her şeyin anlamı, 
 bir dizinin adının aslında bir işaretçi olduğudur. 
 Başından beri işaretçilerle çalıştın 
 her dizi kullandığınızda. 
 Değişken kapsamındaki örnekten hatırlayın, 
 videonun sonuna yakın bir fonksiyonumuz var. 
 set int ve set dizisi olarak adlandırılan bir işlev olarak adlandırılır. 

Dutch: 
 Als arr een reeks dubbels is, dan is & arr vierkante haak i een aanwijzer 
 tot een dubbel. 
 OK. 
 arr vierkante haak i, als arr een reeks dubbels is, 
 dan is arr vierkante haak i het i -de element van die array, 
 en & arr vierkante haak i is waar in het geheugen het i-de element arr aanwezig is. 
 >> Dus wat is de implicatie hier? 
 Een arraysnaam, de implicatie van dit hele ding, 
 is dat de naam van een array eigenlijk zelf een aanwijzer is. 
 Je werkt al die tijd met verwijzingen 
 elke keer dat je een array hebt gebruikt. 
 Onthoud uit het voorbeeld over variabele reikwijdte, 
 tegen het einde van de video presenteer ik een voorbeeld waar we een functie hebben 
 genaamd set int en een functie genaamd set array. 

Italian: 
 Se arr è una matrice di doppi, allora & arr parentesi quadra i è un puntatore 
 per un doppio. 
 OK. 
 parentesi quadra i, se arr è una matrice di doppi, 
 quindi la parentesi quadra i è l'elemento i-esimo di quell'array, 
 e & arr parentesi quadra i è dove in memoria esiste l'i-esimo elemento di arr. 
 >> Quindi qual è l'implicazione qui? 
 Un nome di array, le implicazioni di tutto questo, 
 è che il nome di un array è in realtà un puntatore. 
 Hai sempre lavorato con i puntatori 
 ogni volta che hai usato un array. 
 Ricorda dall'esempio su ambito variabile, 
 verso la fine del video vi presento un esempio in cui abbiamo una funzione 
 chiamato set int e una funzione chiamata set array. 

French: 
 Si arr est un tableau de doubles, alors le crochet carré & arr i est un pointeur 
 au double. 
 D'ACCORD. 
 arr crochet i, si arr est un tableau de doubles, 
 puis arr crochet i est le i-ème élément de ce tableau, 
 et & arr crochet carré i est l'endroit où en mémoire le i-ème élément d'arr existe. 
 >> Alors, quelle est l'implication ici? 
 Un nom de tableau, l'implication de tout cela, 
 est que le nom d'un tableau est en fait lui-même un pointeur. 
 Vous avez toujours travaillé avec des pointeurs 
 chaque fois que vous avez utilisé un tableau. 
 Rappelez-vous de l'exemple sur la portée variable, 
 vers la fin de la vidéo, je présente un exemple où nous avons une fonction 
 appelé set int et une fonction appelée set array. 

Chinese: 
如果arr是双精度数组，则＆arr方括号i是指针
翻倍
好。 
 arr方括号i，如果arr是双精度数组， 
那么arr方括号i是该数组的第i个元素， 
 ＆方括号i是内存中第i个元素存在的位置。 
 >>那么这意味着什么？ 
数组名称，整个含义
是数组的名称实际上本身就是一个指针。 
您一直都在使用指针
每次使用数组时。 
请记住，在有关可变范围的示例中， 
在视频的结尾附近，我举了一个例子，我们有一个功能
称为set int和称为set array的函数。 

German: 
 Wenn arr ein Array von Doubles ist, dann ist & arr eckige Klammer i ein Zeiger 
 zu einem Doppel. 
 OKAY. 
 arr eckige Klammer i, wenn arr eine Anordnung von Doppelwerten ist, 
 dann ist die eckige Klammer i das i-te Element dieses Arrays. 
 und & arr eckige Klammer i ist, wo im Speicher das i-te Element von arr existiert. 
 >> Was bedeutet das hier? 
 Ein Arrays Name, die Implikation dieser ganzen Sache, 
 ist, dass der Name eines Arrays selbst ein Zeiger ist. 
 Sie haben die ganze Zeit mit Zeigern gearbeitet 
 jedes Mal, wenn Sie ein Array verwendet haben. 
 Denken Sie an das Beispiel zum variablen Bereich: 
 Gegen Ende des Videos präsentiere ich ein Beispiel, in dem wir eine Funktion haben 
 genannt set int und eine Funktion namens set array. 

Chinese: 
如果arr是雙精度數組，則＆arr方括號i是指針
翻倍
好。 
 arr方括號i，如果arr是雙精度數組， 
那麼arr方括號i是該數組的第i個元素， 
 ＆方括號i是內存中第i個元素存在的位置。 
 >>那麼這意味著什麼？ 
數組名稱，整個含義
是數組的名稱實際上本身就是一個指針。 
您一直都在使用指針
每次使用數組時。 
請記住，在有關可變範圍的示例中， 
在視頻的結尾附近，我舉了一個例子，我們有一個功能
稱為set int和稱為set array的函數。 

Hindi: 
 अगर गिरफ्तारी डबल्स की एक सरणी है, तो & स्क्वायर ब्रैकेट i एक पॉइंटर है 
 एक डबल करने के लिए। 
 ठीक। 
 गिरफ्तारी चौकोर वर्ग i, अगर गिरफ्तारी युगल की एक सरणी है, 
 तब गिरफ्तार वर्ग कोष्ठक मैं उस सरणी का i-th तत्व है, 
 और गिरफ्तार चौकोर कोष्ठक जहाँ मैं स्मृति में गिरफ्तारी का i-th तत्व मौजूद है। 
 >> तो यहाँ निहितार्थ क्या है? 
 एक सरणि नाम, इस पूरी बात का निहितार्थ, 
 यह है कि एक सरणी का नाम वास्तव में एक संकेतक है। 
 आप सभी के साथ संकेत के साथ काम कर रहे हैं 
 हर बार जब आपने एक सरणी का उपयोग किया है। 
 चर दायरे पर उदाहरण से याद रखें, 
 वीडियो के अंत के पास मैं एक उदाहरण प्रस्तुत करता हूं जहां हमारे पास एक फ़ंक्शन है 
 सेट इंट और एक फ़ंक्शन जिसे सेट एरे कहा जाता है। 

Russian: 
 Если arr - массив значений типа double, то & arr квадратная скобка i - указатель 
 в два раза. 
 ОК. 
 arr квадратная скобка i, если arr массив массивов, 
 тогда arr квадратная скобка i это i-й элемент этого массива, 
 и & arr квадратная скобка i, где в памяти существует i-й элемент arr. 
 >> Так в чем тут смысл? 
 Имя массива, значение всего этого, 
 является то, что имя массива на самом деле является указателем. 
 Вы работали с указателями все время 
 каждый раз, когда вы использовали массив. 
 Помните из примера о переменной области, 
 ближе к концу видео я представляю пример, где у нас есть функция 
 называется set int и функция называется set array. 

Japanese: 
 arrがdoubleの配列の場合、＆arr大括弧iはポインターです
ダブルに。 
 OK。 
 arr角括弧i、arrがdoubleの配列の場合、 
次に、大括弧iはその配列のi番目の要素です。 
 ＆arr角括弧iは、メモリ内でarrのi番目の要素が存在する場所です。 
 >>では、ここでの意味は何ですか？ 
配列名、この全体の意味、 
配列の名前は実際にはそれ自体がポインタであるということです。 
あなたはずっとポインタを使ってきました
配列を使用するたびに。 
変数スコープの例から覚えておいてください、 
ビデオの終わり近くに、関数がある例を示します
 set intと呼ばれる関数とset arrayと呼ばれる関数。 

Arabic: 
 إذا كانت arr عبارة عن مصفوفة من الزوجي ، فإن قوس مربع & arr هو مؤشر 
 إلى ضعف. 
 حسنا. 
 arr square bracket i ، إذا كان arr عبارة عن مصفوفة من الزوجي ، 
 ثم arr القوس المربّع i هو العنصر الأول من ذلك الصفيف ، 
 و & قوس arr مربع i هو المكان الذي يوجد فيه العنصر الأول من الذاكرة. 
 >> إذن ما هو المضمون هنا؟ 
 اسم صفائف ، ضمنا هذا الأمر كله ، 
 هو أن اسم المصفوفة هو في الواقع مؤشر. 
 لقد كنت تعمل مع المؤشرات طوال الوقت 
 في كل مرة تستخدم فيها مصفوفة. 
 تذكر من المثال على النطاق المتغير ، 
 قرب نهاية الفيديو ، أقدم مثالًا حيث لدينا وظيفة 
 تسمى مجموعة int ووظيفة تسمى مجموعة الصفيف. 

Indonesian: 
 Jika arr adalah array dari doubl, maka & arr square bracket i adalah sebuah pointer 
 menjadi ganda. 
 BAIK. 
 braket arr square i, jika arr adalah array ganda, 
 kemudian arr square bracket i adalah elemen ke-i dari array itu, 
 dan & arr bracket persegi i adalah di mana di dalam memori elemen ke-i dari arr ada. 
 >> Jadi apa implikasinya di sini? 
 Nama array, implikasi dari semua ini, 
 adalah bahwa nama array sebenarnya adalah sebuah pointer. 
 Anda telah bekerja dengan pointer selama ini 
 setiap kali Anda menggunakan array. 
 Ingat dari contoh pada lingkup variabel, 
 di dekat akhir video saya menyajikan contoh di mana kita memiliki fungsi 
 disebut set int dan fungsi yang disebut set array. 

Portuguese: 
 Se arr é uma matriz de duplas, então & arr colchete i é um ponteiro 
 para um duplo. 
 ESTÁ BEM. 
 arr colchete i, se arr for uma matriz de duplas, 
 então arr colchete i é o i-ésimo elemento dessa matriz, 
 e & arr colchete i é onde na memória o i-ésimo elemento de arr existe. 
 >> Então, qual é a implicação aqui? 
 Um nome de matriz, a implicação de tudo isso, 
 é que o nome de uma matriz é na verdade um ponteiro. 
 Você tem trabalhado com ponteiros o tempo todo 
 toda vez que você usa uma matriz. 
 Lembre-se do exemplo no escopo da variável, 
 perto do final do vídeo, apresento um exemplo em que temos uma função 
 chamado set int e uma função chamada set array. 

English: 
If arr is an array of doubles, then &arr square bracket i is a pointer
to a double.
OK.
arr square bracket i, if arr is an array of doubles,
then arr square bracket i is the i-th element of that array,
and &arr square bracket i is where in memory the i-th element of arr exists.
>> So what's the implication here?
An arrays name, the implication of this whole thing,
is that an array's name is actually itself a pointer.
You've been working with pointers all along
every time that you've used an array.
Remember from the example on variable scope,
near the end of the video I present an example where we have a function
called set int and a function called set array.

Modern Greek (1453-): 
 Εάν arr είναι μια σειρά διπλών, τότε & arr τετράγωνο bracket i είναι ένας δείκτης 
 σε ένα διπλό. 
 ΕΝΤΑΞΕΙ. 
 arr square bracket i, αν arr είναι μια σειρά διπλών, 
 τότε arr τετράγωνο βραχίονα i είναι το i-th στοιχείο αυτής της συστοιχίας, 
 και & arr square bracket i είναι όπου στη μνήμη υπάρχει i-th στοιχείο του arr. 
 >> Ποιες είναι οι συνέπειες εδώ; 
 Ένα όνομα συστοιχιών, η συνέπεια αυτού του όλου πράγματος, 
 είναι ότι το όνομα ενός πίνακα είναι στην πραγματικότητα το ίδιο δείκτης. 
 Εργάζεστε με δείκτες καθ 'όλη τη διάρκεια 
 κάθε φορά που έχετε χρησιμοποιήσει έναν πίνακα. 
 Θυμηθείτε από το παράδειγμα σχετικά με το μεταβλητό πεδίο, 
 κοντά στο τέλος του βίντεο παρουσιάζω ένα παράδειγμα όπου έχουμε μια λειτουργία 
 που ονομάζεται set int και μια συνάρτηση που ονομάζεται set array. 

Korean: 
 arr이 double의 배열이면 & arr 대괄호 i는 포인터입니다. 
 두 배로. 
 확인. 
 arr 대괄호 i, arr이 복식 배열 인 경우, 
 arr 대괄호 i는 해당 배열의 i 번째 요소입니다. 
 & arr 대괄호 i는 메모리에서 arr의 i 번째 요소가 존재하는 곳입니다. 
 >> 여기에 어떤 의미가 있습니까? 
 배열 이름,이 모든 것의 의미 
 배열의 이름 자체가 실제로 포인터라는 것입니다. 
 당신은 모든 포인터와 함께 일하고있다 
 배열을 사용할 때마다 
 변수 범위의 예에서 기억하십시오. 
 비디오의 끝 근처에서 나는 우리가 함수를 가지는 예제를 제시한다 
 set int라는 함수와 set array라는 함수가 있습니다. 

Spanish: 
 Y su desafío para determinar si o no, o qué 
 valores que imprimimos al final de la función, 
 al final del programa principal. 
 >> Si recuerda de ese ejemplo o si ha visto el video, 
 usted sabe que cuando usted: la llamada a establecer int efectivamente no hace nada. 
 Pero la llamada a establecer matriz sí. 
 Y pasé por alto por qué ese era el caso en ese momento. 
 Solo dije, bueno, es una matriz, es especial, ya sabes, hay una razón. 
 La razón es que el nombre de una matriz es realmente solo un puntero, 
 y existe esta sintaxis especial de corchetes que 
 hacer las cosas mucho más agradables para trabajar. 
 Y hacen que la idea de un puntero sea mucho menos intimidante, 
 y es por eso que se presentan de esa manera. 
 Pero realmente las matrices son solo punteros. 
 Y es por eso que cuando hicimos un cambio en la matriz, 
 cuando pasamos una matriz como parámetro a una función o como argumento 
 a una función, el contenido de la matriz realmente cambió tanto en la persona que llama 
 y en la persona que llama. 
 Lo que para cualquier otro tipo de variable que vimos no fue el caso. 
 Eso es algo a tener en cuenta cuando trabajas con punteros, 

Dutch: 
 En jouw uitdaging om te bepalen of of niet, of wat 
 waarden die we aan het einde van de functie hebben afgedrukt, 
 aan het einde van het hoofdprogramma. 
 >> Als je je dat voorbeeld herinnert of als je de video hebt bekeken, 
 u weet dat wanneer u- de oproep om int effectief in te stellen niets doet. 
 Maar de oproep om de array in te stellen doet dat wel. 
 En ik verdoezelde min of meer waarom dat destijds het geval was. 
 Ik zei net, het is een array, het is speciaal, weet je, er is een reden. 
 De reden is dat de naam van een array eigenlijk slechts een aanwijzer is, 
 en er is een speciale syntaxis van vierkante haken 
 maak het een stuk prettiger om mee te werken. 
 En ze maken het idee van een aanwijzer veel minder intimiderend, 
 en dat is waarom ze zo worden gepresenteerd. 
 Maar echt arrays zijn slechts aanwijzingen. 
 En dat is waarom toen we een wijziging in de array aanbrachten, 
 wanneer we een array doorgeven als parameter aan een functie of als argument 
 naar een functie veranderde de inhoud van de array eigenlijk in zowel de callee 
 en in de beller. 
 Wat voor elke andere soort variabele die we zagen niet het geval was. 
 Dus dat is gewoon iets om in gedachten te houden als je met aanwijzers werkt, 

Japanese: 
そして、あなたの挑戦は、そうであるかどうか、または何を決定する
関数の最後に出力した値、 
メインプログラムの最後。 
 >>その例から思い出したり、ビデオを見たことがある場合は、 
 intを設定するための呼び出しが効果的に何もしないことを知っています。 
しかし、set arrayの呼び出しは行います。 
そして、私はそれがなぜその時そうなっていたのかについて、一種のつやを出しました。 
先ほど言ったとおり、配列であり、特殊であり、理由があります。 
その理由は、配列の名前は実際には単なるポインタであるためです。 
そして、この特別な角括弧構文があります
作業しやすいものにしてください。 
そして、彼らはポインターのアイデアをはるかに脅かしにくくしています、 
だから、そういう風に提示されているのです。 
しかし、実際には配列は単なるポインタです。 
だから、配列に変更を加えたとき、 
配列をパラメータとして関数または引数として渡したとき
関数に対して、配列の内容は実際に両方の呼び出し先で変更されました
そして、呼び出し元で。 
他のすべての種類の変数についてはそうではありませんでした。 
これは、ポインタを操作するときに覚えておくべきことです。 

English: 
And your challenge to determine whether or not, or what the
values that we printed out the end of the function,
at the end of the main program.
>> If you recall from that example or if you've watched the video,
you know that when you- the call to set int effectively does nothing.
But the call to set array does.
And I sort of glossed over why that was the case at the time.
I just said, well it's an array, it's special, you know, there's a reason.
The reason is that an array's name is really just a pointer,
and there's this special square bracket syntax that
make things a lot nicer to work with.
And they make the idea of a pointer a lot less intimidating,
and that's why they're sort of presented in that way.
But really arrays are just pointers.
And that's why when we made a change to the array,
when we passed an array as a parameter to a function or as an argument
to a function, the contents of the array actually changed in both the callee
and in the caller.
Which for every other kind of variable we saw was not the case.
So that's just something to keep in mind when you're working with pointers,

Turkish: 
 Ve sizin 
 işlevin sonuna yazdırdığımız değerler, 
 ana programın sonunda. 
 >> Bu örnekten hatırlarsanız veya videoyu izlediyseniz, 
 Biliyorsunuz ki sen- etkili bir şekilde int kurma çağrısı hiçbir şey yapmaz. 
 Ancak dizi ayarlama çağrısı yapar. 
 Ve o zaman neden böyle olduğunu biraz şaşırttım. 
 Az önce dedim ki, bu bir dizi, özel, bilirsiniz, bir nedeni var. 
 Bunun nedeni, bir dizinin adının gerçekten sadece bir işaretçi olmasıdır, 
 ve bu özel köşeli parantez sözdizimi var 
 işleri daha güzel hale getirin. 
 Ve bir işaretçi fikrini çok daha az korkutucu yaparlar, 
 ve bu yüzden bu şekilde sunuluyorlar. 
 Ama gerçekten diziler sadece işaretçilerdir. 
 Bu yüzden dizide bir değişiklik yaptığımızda, 
 bir diziyi bir işleve parametre olarak veya bağımsız değişken olarak geçirdiğimizde 
 bir işleve, dizinin içeriği aslında her iki callee'de de değişti 
 ve arayanda. 
 Gördüğümüz diğer tüm değişkenler için durum böyle değildi. 
 İşaretçilerle çalışırken akılda tutulması gereken bir şey, 

Korean: 
 그리고 당신의 도전 여부를 결정하거나 
 함수의 끝을 인쇄 한 값 
 메인 프로그램의 끝에서. 
 >> 그 예를 떠올리거나 비디오를 본 경우 
 int를 설정하라는 호출은 아무런 효과가 없다는 것을 알고 있습니다. 
 그러나 배열 설정에 대한 호출은 않습니다. 
 그리고 나는 왜 당시에 그런지에 대해 약간의 영광을 느꼈습니다. 
 방금 말했듯이 배열입니다. 특별한 이유가 있습니다. 
 그 이유는 배열의 이름이 실제로 포인터 일 뿐이므로 
 이 특별한 대괄호 구문은 
 작업을 훨씬 더 멋지게 만듭니다. 
 그리고 그들은 포인터의 아이디어를 훨씬 덜 협박하게 만듭니다. 
 그것이 바로 이런 식으로 제시되는 이유입니다. 
 그러나 실제로 배열은 포인터 일뿐입니다. 
 이것이 우리가 어레이를 변경했을 때의 이유입니다. 
 배열을 매개 변수로 함수 또는 인수로 전달했을 때 
 함수의 경우 배열의 내용은 실제로 수신자 모두에서 변경되었습니다. 
 그리고 발신자. 
 우리가 본 다른 모든 종류의 변수는 그렇지 않았습니다. 
 포인터로 작업 할 때 명심해야 할 사항입니다. 

Chinese: 
您面臨的挑戰是確定是否
我們在函數末尾打印的值， 
在主程序的末尾。 
 >>如果您從該示例中回想起或觀看了視頻， 
您知道，當您調用set int有效時，它什麼也沒做。 
但是調用set array確實可以。 
我有點掩飾當時為什麼會這樣。 
我只是說過，這是一個數組，它很特殊，您知道，這是有原因的。 
原因是數組的名稱實際上只是一個指針， 
這是特殊的方括號語法
使事情變得更好用。 
而且它們使指針的想法變得不那麼嚇人， 
這就是為什麼它們以這種方式呈現的原因。 
但是實際上數組只是指針。 
這就是為什麼當我們對數組進行更改時， 
當我們將數組作為參數傳遞給函數或參數時
到一個函數，數組的內容實際上在兩個被調用方中都已更改
並在呼叫者中。 
我們看到的其他所有變量都不是這種情況。 
因此，在使用指針時，請記住這一點， 

Chinese: 
您面临的挑战是确定是否
我们在函数末尾打印的值， 
在主程序的末尾。 
 >>如果您从该示例中回想起或观看了视频， 
您知道，当您调用set int有效时，它什么也没做。 
但是调用set array确实可以。 
我有点掩饰当时为什么会这样。 
我只是说过，这是一个数组，它很特殊，您知道，这是有原因的。 
原因是数组的名称实际上只是一个指针， 
这是特殊的方括号语法
使事情变得更好用。 
而且它们使指针的想法变得不那么吓人， 
这就是为什么它们以这种方式呈现的原因。 
但是实际上数组只是指针。 
这就是为什么当我们对数组进行更改时， 
当我们将数组作为参数传递给函数或参数时
到一个函数，数组的内容实际上在两个被调用方中都已更改
并在呼叫者中。 
我们看到的其他所有变量都不是这种情况。 
因此，在使用指针时，请记住这一点， 

Arabic: 
 والتحدي الخاص بك لتحديد ما إذا كان أم لا 
 القيم التي قمنا بطباعتها نهاية الدالة ، 
 في نهاية البرنامج الرئيسي. 
 >> إذا تذكرت من هذا المثال أو إذا شاهدت الفيديو ، 
 أنت تعلم أنه عندما - دعوة المكالمة لا تفعل شيئا بشكل فعال. 
 ولكن الدعوة لتعيين مجموعة. 
 وأنا نوعا ما تمحى حول لماذا كان هذا هو الحال في ذلك الوقت. 
 لقد قلت للتو ، حسنًا ، إنها مجموعة ، إنها خاصة ، كما تعلم ، هناك سبب. 
 والسبب هو أن اسم المصفوفة هو مؤشر فقط ، 
 وهناك هذا التركيب الخاص بين قوسين معقوفين 
 جعل الأشياء أجمل للعمل معها. 
 ويجعلون فكرة المؤشر أقل تخويفًا بكثير ، 
 ولهذا السبب يتم تقديمهم بهذه الطريقة. 
 لكن المصفوفات هي مجرد مؤشرات. 
 ولهذا عندما قمنا بإجراء تغيير على المصفوفة ، 
 عندما مررنا مصفوفة كمعلمة لدالة أو كوسيطة 
 إلى دالة ، تغيرت محتويات المصفوفة بالفعل في كل من callee 
 وفي المتصل. 
 وهو ما لم يكن هو الحال بالنسبة لكل نوع آخر من المتغيرات. 
 هذا فقط شيء يجب أن تضعه في الاعتبار عند العمل مع المؤشرات ، 

Italian: 
 E la tua sfida per determinare se o no, o quale 
 valori che abbiamo stampato alla fine della funzione, 
 alla fine del programma principale. 
 >> Se ricordi da quell'esempio o se hai guardato il video, 
 sai che quando tu- la chiamata a impostare int in modo efficace non fa nulla. 
 Ma la chiamata per impostare l'array lo fa. 
 E in un certo senso ho scoperto il motivo per cui era il caso in quel momento. 
 Ho appena detto, beh, è ​​un array, è speciale, sai, c'è una ragione. 
 Il motivo è che il nome di un array è in realtà solo un puntatore, 
 e c'è questa speciale sintassi con parentesi quadre 
 rendere le cose molto più belle con cui lavorare. 
 E rendono l'idea di un puntatore molto meno intimidatoria, 
 ed è per questo che sono presentati in quel modo. 
 Ma davvero gli array sono solo dei puntatori. 
 Ed è per questo che quando abbiamo apportato una modifica alla matrice, 
 quando abbiamo passato un array come parametro a una funzione o come argomento 
 in una funzione, il contenuto dell'array in realtà è cambiato sia nella chiamata 
 e nel chiamante. 
 Che per ogni altro tipo di variabile che abbiamo visto non era il caso. 
 Quindi è solo qualcosa da tenere a mente quando lavori con i puntatori, 

Russian: 
 И ваша задача определить, или нет, или что 
 значения, которые мы распечатали в конце функции, 
 в конце основной программы. 
 >> Если вы помните из этого примера или если вы смотрели видео, 
 вы знаете, что когда вы - вызов для установки int эффективно ничего не делает. 
 Но вызов для установки массива делает. 
 И я в некотором роде замять, почему это было так в то время. 
 Я просто сказал, ну, это массив, он особенный, знаете, есть причина. 
 Причина в том, что имя массива на самом деле просто указатель, 
 и есть этот специальный синтаксис квадратных скобок, который 
 сделать вещи намного приятнее работать. 
 И они делают идею указателя намного менее пугающей, 
 и именно поэтому они вроде представлены таким образом. 
 Но на самом деле массивы - это просто указатели. 
 И именно поэтому, когда мы внесли изменения в массив, 
 когда мы передали массив в качестве параметра функции или в качестве аргумента 
 к функции, содержимое массива фактически изменилось как в вызываемом 
 и в звонилке. 
 Что для любой другой переменной, которую мы видели, было не так. 
 Так что это только то, что нужно иметь в виду, когда вы работаете с указателями, 

French: 
 Et votre défi de déterminer si oui ou non, ou ce que le 
 valeurs que nous avons imprimées à la fin de la fonction, 
 à la fin du programme principal. 
 >> Si vous vous souvenez de cet exemple ou si vous avez regardé la vidéo, 
 vous savez que lorsque vous - l'appel à set int ne fait rien. 
 Mais l'appel à définir un tableau le fait. 
 Et j'ai en quelque sorte passé sous silence pourquoi c'était le cas à l'époque. 
 Je viens de dire, eh bien c'est un tableau, c'est spécial, vous savez, il y a une raison. 
 La raison en est que le nom d'un tableau n'est en fait qu'un pointeur, 
 et il y a cette syntaxe spéciale entre crochets 
 rendre les choses beaucoup plus agréables à travailler. 
 Et ils rendent l'idée d'un pointeur beaucoup moins intimidante, 
 et c'est pourquoi ils sont en quelque sorte présentés de cette façon. 
 Mais vraiment les tableaux ne sont que des pointeurs. 
 Et c'est pourquoi lorsque nous avons modifié le tableau, 
 lorsque nous avons passé un tableau en tant que paramètre d'une fonction ou en tant qu'argument 
 à une fonction, le contenu du tableau a effectivement changé à la fois dans l'appelé 
 et dans l'appelant. 
 Ce qui n'était pas le cas pour tous les autres types de variables que nous avons vues. 
 Voilà donc quelque chose à garder à l'esprit lorsque vous travaillez avec des pointeurs, 

Portuguese: 
 E seu desafio para determinar se é ou não ou o que 
 valores que imprimimos no final da função, 
 no final do programa principal. 
 >> Se você se lembra desse exemplo ou se assistiu ao vídeo, 
 você sabe que quando você - a chamada para definir int efetivamente não faz nada. 
 Mas a chamada para definir a matriz faz. 
 E eu meio que encaminhei o motivo pelo qual esse era o caso na época. 
 Eu apenas disse, bem, é uma matriz, é especial, você sabe, há uma razão. 
 O motivo é que o nome de uma matriz é realmente apenas um ponteiro, 
 e há essa sintaxe especial entre colchetes que 
 tornar as coisas muito mais agradáveis ​​de se trabalhar. 
 E eles tornam a idéia de um ponteiro muito menos intimidadora, 
 e é por isso que eles são apresentados dessa maneira. 
 Mas realmente matrizes são apenas indicadores. 
 E é por isso que, quando fizemos uma alteração na matriz, 
 quando passamos uma matriz como parâmetro para uma função ou como argumento 
 para uma função, o conteúdo da matriz realmente mudou tanto no chamado 
 e no chamador. 
 Que para todos os outros tipos de variáveis ​​que vimos não era o caso. 
 Portanto, isso é algo que você deve ter em mente quando estiver trabalhando com ponteiros, 

Indonesian: 
 Dan tantangan Anda untuk menentukan apakah atau tidak, atau apa 
 nilai yang kami cetak di akhir fungsi, 
 di akhir program utama. 
 >> Jika Anda ingat dari contoh itu atau jika Anda telah menonton video, 
 Anda tahu bahwa ketika Anda - panggilan untuk mengatur int secara efektif tidak melakukan apa-apa. 
 Tetapi panggilan untuk mengatur array tidak. 
 Dan saya agak bingung mengapa itu terjadi pada saat itu. 
 Saya hanya berkata, baik itu array, ini spesial, Anda tahu, ada alasannya. 
 Alasannya adalah bahwa nama array benar-benar hanya sebuah pointer, 
 dan ada sintaks braket persegi khusus ini 
 membuat banyak hal lebih baik untuk dikerjakan. 
 Dan mereka membuat gagasan tentang penunjuk jauh lebih tidak menakutkan, 
 dan itulah sebabnya mereka disajikan seperti itu. 
 Tapi sebenarnya array hanyalah petunjuk. 
 Dan itu sebabnya ketika kami membuat perubahan ke array, 
 ketika kami melewatkan array sebagai parameter ke fungsi atau sebagai argumen 
 untuk suatu fungsi, isi array sebenarnya berubah di kedua callee 
 dan di pemanggil. 
 Yang untuk setiap jenis variabel lain yang kami lihat tidak demikian. 
 Jadi itu hanya sesuatu yang perlu diingat ketika Anda bekerja dengan pointer, 

German: 
 Und Ihre Herausforderung zu bestimmen, ob oder was oder was die 
 Werte, die wir am Ende der Funktion ausgedruckt haben, 
 am Ende des Hauptprogramms. 
 >> Wenn Sie sich an dieses Beispiel erinnern oder das Video gesehen haben, 
 Sie wissen, dass der Aufruf von int nichts effektiv bewirkt, wenn Sie dies tun. 
 Der Aufruf zum Festlegen des Arrays funktioniert jedoch. 
 Und ich habe irgendwie beschönigt, warum das damals der Fall war. 
 Ich habe nur gesagt, es ist ein Array, es ist etwas Besonderes, weißt du, es gibt einen Grund. 
 Der Grund ist, dass der Name eines Arrays wirklich nur ein Zeiger ist. 
 und es gibt diese spezielle eckige Klammer-Syntax, die 
 machen die Dinge viel schöner zu arbeiten. 
 Und sie machen die Idee eines Zeigers viel weniger einschüchternd, 
 und deshalb werden sie so präsentiert. 
 Aber wirklich Arrays sind nur Zeiger. 
 Und deshalb, als wir das Array geändert haben, 
 wenn wir ein Array als Parameter an eine Funktion oder als Argument übergeben haben 
 Für eine Funktion hat sich der Inhalt des Arrays in beiden Angerufenen tatsächlich geändert 
 und im Anrufer. 
 Was für jede andere Art von Variable, die wir sahen, nicht der Fall war. 
 Das ist also nur etwas, das Sie beachten sollten, wenn Sie mit Zeigern arbeiten. 

Modern Greek (1453-): 
 Και η πρόκλησή σας να προσδιορίσετε εάν ή όχι, ή τι 
 τιμές που εκτυπώσαμε το τέλος της λειτουργίας, 
 στο τέλος του κύριου προγράμματος. 
 >> Αν θυμάστε από το παράδειγμα αυτό ή αν έχετε παρακολουθήσει το βίντεο, 
 ξέρετε ότι όταν εσείς - η κλήση για να ορίσετε int αποτελεσματικά δεν κάνει τίποτα. 
 Αλλά η κλήση για να ορίσετε πίνακα κάνει. 
 Και το είδος μου έλεγε για ποιο λόγο συνέβαινε εκείνη τη στιγμή. 
 Μόλις είπα, είναι μια σειρά, είναι ξεχωριστή, ξέρετε, υπάρχει ένας λόγος. 
 Ο λόγος είναι ότι το όνομα ενός πίνακα είναι πραγματικά ένας δείκτης, 
 και υπάρχει αυτή η ειδική σύνταξη τετράγωνου βραχίονα ότι 
 κάνει τα πράγματα πολύ καλύτερο να συνεργαστεί. 
 Και κάνουν την ιδέα ενός δείκτη πολύ λιγότερο εκφοβιστικό, 
 και γι 'αυτό παρουσιάζονται με αυτόν τον τρόπο. 
 Αλλά πραγματικά πίνακες είναι μόνο δείκτες. 
 Και γι 'αυτό όταν κάναμε μια αλλαγή στον πίνακα, 
 όταν περάσαμε μια παράταξη ως παράμετρο σε μια συνάρτηση ή ως επιχείρημα 
 σε μια συνάρτηση, τα περιεχόμενα της συστοιχίας άλλαξαν στην πραγματικότητα και στους δύο καλούντες 
 και στον καλούντα. 
 Ποια για κάθε άλλη μεταβλητή που είδαμε δεν συνέβαινε. 
 Αυτό είναι ακριβώς κάτι που πρέπει να θυμάστε όταν δουλεύετε με δείκτες, 

Hindi: 
 और आपकी चुनौती यह निर्धारित करने के लिए कि क्या है या क्या नहीं 
 मान जो हमने फ़ंक्शन के अंत में प्रिंट किए थे, 
 मुख्य कार्यक्रम के अंत में। 
 >> यदि आप उस उदाहरण से याद करते हैं या यदि आपने वीडियो देखा है, 
 आप जानते हैं कि जब आप- int सेट करने के लिए कॉल प्रभावी रूप से कुछ नहीं करता है। 
 लेकिन सरणी सेट करने के लिए कॉल करता है। 
 और मैं उस समय ऐसा क्यों था, इस पर ग्लॉस्ड हो गया। 
 मैंने कहा, अच्छा है यह एक सरणी है, यह विशेष है, आप जानते हैं, इसका एक कारण है। 
 कारण यह है कि एक सरणी का नाम वास्तव में सिर्फ एक संकेतक है, 
 और इस विशेष वर्ग कोष्ठक वाक्य रचना है 
 काम करने के लिए चीजों को बहुत अच्छा बनाएं। 
 और वे एक पॉइंटर के विचार को बहुत कम भयभीत करते हैं, 
 और इसीलिए वे उस तरह से प्रस्तुत किए गए हैं। 
 लेकिन वास्तव में सरणियाँ सिर्फ संकेत हैं। 
 और इसीलिए जब हमने सरणी में बदलाव किया, 
 जब हम किसी सरणी को एक पैरामीटर के रूप में फ़ंक्शन या तर्क के रूप में पास करते हैं 
 एक फ़ंक्शन के लिए, सरणी की सामग्री वास्तव में दोनों केली में बदल गई 
 और फोन करने वाले में। 
 हर दूसरे प्रकार के चर के लिए जो हमने देखा वह मामला नहीं था। 
 तो जब आप पॉइंटर्स के साथ काम कर रहे हों तो बस कुछ ध्यान रखना चाहिए, 

Arabic: 
 هو أن اسم مصفوفة مؤشر بالفعل 
 إلى العنصر الأول من هذا الصفيف. 
 >> حسنًا ، لدينا الآن كل هذه الحقائق ، فلنستمر ، صحيح. 
 لماذا نهتم أين يعيش شيء ما. 
 حسنًا كما قلت ، من المفيد جدًا معرفة أين يعيش شيء ما 
 حتى تتمكن من الذهاب إلى هناك وتغييره. 
 اعمل معها ولديك في الواقع الشيء الذي تريده 
 تريد أن تفعل ذلك المتغير ساري المفعول ، وليس ساري المفعول على نسخة منه. 
 وهذا ما يسمى بإلغاء الإشارة. 
 نذهب إلى المرجع ونغير القيمة هناك. 
 لذلك إذا كان لدينا مؤشر ويسمى جهاز الكمبيوتر ، ويشير إلى حرف ، 
 ثم يمكننا أن نقول * pc و * pc هو اسم ما سنجده إذا ذهبنا 
 إلى عنوان الكمبيوتر. 
 ما سنجده هو حرف و * كمبيوتر هو كيف نشير إلى البيانات في ذلك 
 موقعك. 
 لذا يمكننا قول شيء مثل * pc = D أو شيء من هذا القبيل ، 
 وهذا يعني أن كل ما كان في كمبيوتر عنوان الذاكرة ، 

Italian: 
 è che il nome di un array in realtà è un puntatore 
 al primo elemento di quell'array. 
 >> OK, quindi ora abbiamo tutti questi fatti, continuiamo, giusto. 
 Perché ci interessa dove abita qualcosa. 
 Bene, come ho detto, è abbastanza utile sapere dove vive qualcosa 
 così puoi andare lì e cambiarlo. 
 Lavora con esso e in realtà hai la cosa che tu 
 vuoi che la variabile abbia effetto e non abbia effetto su una sua copia. 
 Questo si chiama dereferenziazione. 
 Andiamo al riferimento e cambiamo il valore lì. 
 Quindi se abbiamo un puntatore e si chiama pc, e punta a un personaggio, 
 allora possiamo dire * pc e * pc è il nome di ciò che troveremo se andiamo 
 all'indirizzo pc. 
 Quello che troveremo è un personaggio e * pc è il modo in cui ci riferiamo ai dati 
 Posizione. 
 Quindi potremmo dire qualcosa del tipo * pc = D o qualcosa del genere, 
 e ciò significa che qualunque cosa fosse in memoria indirizzo pc, 

German: 
 ist, dass der Name eines Arrays tatsächlich ein Zeiger ist 
 zum ersten Element dieses Arrays. 
 >> OK, jetzt haben wir all diese Fakten, lass uns weitermachen, richtig. 
 Warum interessiert es uns, wo etwas lebt? 
 Nun, wie ich schon sagte, es ist ziemlich nützlich zu wissen, wo etwas lebt 
 so können Sie dorthin gehen und es ändern. 
 Arbeiten Sie damit und haben Sie tatsächlich das, was Sie 
 Ich möchte, dass diese Variable wirksam wird und nicht auf eine Kopie davon wirkt. 
 Dies wird als Dereferenzierung bezeichnet. 
 Wir gehen zur Referenz und ändern dort den Wert. 
 Wenn wir also einen Zeiger haben, der PC heißt und auf ein Zeichen zeigt, 
 dann können wir sagen * pc und * pc ist der Name dessen, was wir finden werden, wenn wir gehen 
 an die Adresse pc. 
 Was wir dort finden werden, ist ein Zeichen und * pc ist, wie wir uns dabei auf die Daten beziehen 
 Lage. 
 Also könnten wir so etwas wie * pc = D oder so etwas sagen, 
 und das bedeutet, dass was auch immer an der Speicheradresse PC war, 

Modern Greek (1453-): 
 είναι ότι το όνομα ενός πίνακα πράγματι ένας δείκτης 
 στο πρώτο στοιχείο αυτής της συστοιχίας. 
 >> Εντάξει, τώρα έχουμε όλα αυτά τα γεγονότα, ας συνεχίσουμε, σωστά. 
 Γιατί μας νοιάζει πού ζει κάτι. 
 Λοιπόν όπως είπα, είναι πολύ χρήσιμο να γνωρίζετε πού ζει κάτι 
 έτσι μπορείτε να πάτε εκεί και να το αλλάξετε. 
 Συνεργαστείτε με αυτό και πραγματικά έχετε το πράγμα που εσείς 
 θέλετε να κάνετε αυτήν τη μεταβλητή να ισχύσει και να μην ισχύσει σε κάποιο αντίγραφο αυτής. 
 Αυτό ονομάζεται αποδέσμευση. 
 Πηγαίνουμε στην αναφορά και αλλάζουμε την αξία εκεί. 
 Έτσι εάν έχουμε έναν δείκτη και ονομάζεται pc, και δείχνει έναν χαρακτήρα, 
 τότε μπορούμε να πούμε * pc και * pc είναι το όνομα του τι θα βρούμε αν πάμε 
 στη διεύθυνση διεύθυνση ηλεκτρονικού ταχυδρομείου. 
 Αυτό που θα βρούμε είναι ένας χαρακτήρας και * ο υπολογιστής είναι ο τρόπος που αναφερόμαστε στα δεδομένα σε αυτό 
 τοποθεσία. 
 Έτσι θα μπορούσαμε να πούμε κάτι σαν * pc = D ή κάτι τέτοιο, 
 και αυτό σημαίνει ότι ό, τι ήταν στη διεύθυνση μνήμης pc, 

Turkish: 
 bir dizinin adı aslında bir işaretçi olmasıdır 
 dizinin ilk öğesine ekler. 
 >> Tamam şimdi tüm bu gerçeklere sahibiz, devam edelim, doğru. 
 Neden bir şeyin nerede yaşadığını önemsiyoruz. 
 Dediğim gibi, bir şeyin nerede yaşadığını bilmek oldukça faydalı 
 böylece oraya gidip değiştirebilirsiniz. 
 Onunla çalışın ve aslında sizin 
 bu değişkenin yürürlüğe girmesini ve bazı kopyalarında yürürlüğe girmesini istemiyorum. 
 Buna kayıt silme denir. 
 Referansa gidiyoruz ve oradaki değeri değiştiriyoruz. 
 Eğer bir işaretçimiz varsa ve buna pc deniyorsa ve bir karakteri gösteriyorsa, 
 o zaman diyebiliriz * pc ve * pc gidersek bulacağımızın adı 
 adres pc. 
 Ne bir karakter bulacağız ve * pc oradaki verilere nasıl atıfta bulunduğumuz 
 yer. 
 * Pc = D gibi bir şey söyleyebiliriz, 
 ve bu, bellek adresi pc'de ne varsa, 

Chinese: 
是數組的名稱實際上是一個指針
到該數組的第一個元素。 
 >>好，現在我們有了所有這些事實，讓我們繼續吧。 
我們為什麼要關心某些地方。 
就像我說的，知道某物在哪裡非常有用
所以你可以去那裡改變它。 
使用它並真正擁有您所擁有的東西
想要使該變量生效，而不是對該變量的某些副本生效。 
這稱為取消引用。 
我們去參考，然後在那改變值。 
因此，如果我們有一個稱為pc的指針，它指向一個字符， 
那麼我們可以說* pc和* pc是我們找到的名稱
到地址pc。 
我們會發現有一個字符，而* pc是我們在該處引用數據的方式
位置。 
所以我們可以說* pc = D之類的話， 
這意味著無論在內存地址pc上， 

Spanish: 
 es que el nombre de una matriz en realidad es un puntero 
 al primer elemento de esa matriz. 
 >> Bien, así que ahora tenemos todos estos hechos, sigamos, correcto. 
 ¿Por qué nos importa dónde vive algo? 
 Bueno, como dije, es bastante útil saber dónde vive algo 
 para que puedas ir allí y cambiarlo. 
 Trabaja con él y en realidad ten lo que tú 
 querer hacer que esa variable surta efecto y no surta efecto en alguna copia de la misma. 
 Esto se llama desreferenciación. 
 Vamos a la referencia y cambiamos el valor allí. 
 Entonces, si tenemos un puntero y se llama pc, y apunta a un personaje, 
 entonces podemos decir * pc y * pc es el nombre de lo que encontraremos si vamos 
 a la dirección pc. 
 Lo que encontraremos allí es un carácter y * pc es cómo nos referimos a los datos en ese 
 ubicación. 
 Entonces podríamos decir algo como * pc = D o algo así, 
 y eso significa que lo que estaba en la dirección de memoria de la PC, 

Korean: 
 배열의 이름이 실제로 포인터라는 것입니다. 
 해당 배열의 첫 번째 요소에. 
 >> 자 이제 우리는이 모든 사실들을 가지고 있습니다. 계속하겠습니다. 
 왜 우리는 무언가가 어디에 있는지에 관심이 있습니까? 
 내가 말했듯이, 무언가가 어디에 있는지 아는 것이 매우 유용합니다. 
 거기 가서 갈 수 있습니다. 
 그것으로 작업하고 실제로 당신이 가지고있는 것을 가지고 
 해당 변수에 영향을 미치려면 일부 변수에는 적용되지 않습니다. 
 이것을 역 참조라고합니다. 
 참조로 가서 값을 변경합니다. 
 포인터가 있고 pc라고하고 문자를 가리키면 
 우리는 * pc라고 말할 수 있고 * pc는 우리가 가면 찾을 것의 이름입니다 
 주소 pc에. 
 우리가 찾을 수있는 것은 문자가 있고 * pc는 그 데이터를 참조하는 방법입니다. 
 위치. 
 그래서 우리는 * pc = D 또는 이와 유사한 것을 말할 수 있습니다. 
 즉, 메모리 주소 pc에 있던 모든 것이 

French: 
 est que le nom d'un tableau est en fait un pointeur 
 au premier élément de ce tableau. 
 >> OK alors maintenant nous avons tous ces faits, continuons, d'accord. 
 Pourquoi nous soucions-nous de l'endroit où vit quelque chose. 
 Eh bien, comme je l'ai dit, il est assez utile de savoir où vit quelque chose 
 afin que vous puissiez y aller et le changer. 
 Travaillez avec et ayez réellement la chose que vous 
 voulez faire pour que cette variable prenne effet, et ne prenne pas effet sur une copie de celle-ci. 
 C'est ce qu'on appelle le déréférencement. 
 Nous allons à la référence et nous changeons la valeur là-bas. 
 Donc, si nous avons un pointeur et il s'appelle pc, et il pointe vers un personnage, 
 alors nous pouvons dire * pc et * pc est le nom de ce que nous trouverons si nous allons 
 à l'adresse pc. 
 Ce que nous trouverons, il y a un caractère et * pc est la façon dont nous nous référons aux données à ce 
 emplacement. 
 On pourrait donc dire quelque chose comme * pc = D ou quelque chose comme ça, 
 et cela signifie que tout ce qui était à l'adresse mémoire pc, 

Hindi: 
 यह है कि एक सरणी का नाम वास्तव में एक सूचक है 
 उस सरणी के पहले तत्व के लिए। 
 >> ठीक है तो अब हमारे पास ये सभी तथ्य हैं, चलो ठीक है, चलते रहो। 
 हम क्यों परवाह करते हैं कि कुछ कहाँ रहता है। 
 खैर जैसे मैंने कहा, यह जानना बहुत उपयोगी है कि कुछ कहाँ रहता है 
 तो आप वहां जा सकते हैं और इसे बदल सकते हैं। 
 इसके साथ काम करें और वास्तव में वह चीज है जो आप 
 उस चर को प्रभावी करना चाहते हैं, और इसकी कुछ प्रति पर प्रभाव नहीं लेना चाहते हैं। 
 इसे डेरेफेरिंग कहा जाता है। 
 हम संदर्भ पर जाते हैं और हम वहां मूल्य बदलते हैं। 
 इसलिए अगर हमारे पास एक पॉइंटर है और इसे पीसी कहा जाता है, और यह एक चरित्र की ओर इशारा करता है, 
 तो हम कह सकते हैं * पीसी और * पीसी नाम है कि हम क्या पाएंगे अगर हम जाते हैं 
 पता करने के लिए पीसी। 
 हम पाएंगे कि एक वर्ण है और * pc है कि हम उस पर डेटा को कैसे संदर्भित करते हैं 
 स्थान। 
 तो हम कुछ कह सकते हैं जैसे * pc = D या ऐसा कुछ, 
 और इसका मतलब है कि जो कुछ भी मेमोरी एड्रेस पीसी पर था, 

Russian: 
 является то, что имя массива на самом деле указатель 
 к первому элементу этого массива. 
 >> Хорошо, теперь у нас есть все эти факты, давайте продолжим, верно. 
 Почему мы заботимся о том, где что-то живет. 
 Ну, как я уже сказал, очень полезно знать, где что-то живет 
 так что вы можете пойти туда и изменить его. 
 Работайте с ним и на самом деле есть то, что вы 
 хотите, чтобы эта переменная вступила в силу, а не вступила в силу для некоторой ее копии. 
 Это называется разыменованием. 
 Переходим к ссылке и меняем значение там. 
 Так что, если у нас есть указатель, и он называется ПК, и он указывает на символ, 
 тогда мы можем сказать * pc и * pc это имя того, что мы найдем, если мы пойдем 
 по адресу шт. 
 То, что мы найдем, это символ, а * pc - это то, как мы обращаемся к данным. 
 расположение. 
 Таким образом, мы могли бы сказать что-то вроде * pc = D или что-то в этом роде, 
 и это означает, что все, что было по адресу памяти ПК, 

Chinese: 
是数组的名称实际上是一个指针
到该数组的第一个元素。 
 >>好，现在我们有了所有这些事实，让我们继续吧。 
我们为什么要关心某些地方。 
就像我说的，知道某物在哪里非常有用
所以你可以去那里改变它。 
使用它并真正拥有您所拥有的东西
想要使该变量生效，而不是对该变量的某些副本生效。 
这称为取消引用。 
我们去参考，然后在那改变值。 
因此，如果我们有一个称为pc的指针，它指向一个字符， 
那么我们可以说* pc和* pc是我们找到的名称
到地址pc。 
我们会发现有一个字符，而* pc是我们在该处引用数据的方式
位置。 
所以我们可以说* pc = D之类的话， 
这意味着无论在内存地址pc上， 

Japanese: 
配列の名前は実際にはポインタであることです
その配列の最初の要素に。 
 >>はい、これでこれらすべての事実がわかったので、続けましょう。 
なぜ私たちは何かがどこに住んでいるのか気にしています
私が言ったように、何かがどこに住んでいるかを知ることはかなり役に立ちます
そこに行って変更できます
それを使って実際にあなたが
その変数を有効にし、その一部のコピーでは有効にしないようにします。 
これは逆参照と呼ばれます。 
参照に行き、そこで値を変更します。 
したがって、ポインタがあり、それがpcと呼ばれ、それが文字を指している場合、 
次に、* pcと言うことができます。* pcは、移動したときに見つけるものの名​​前です。 
アドレスpcに。 
そこには文字があり、* pcはそのデータを参照する方法です。 
ロケーション。 
つまり、* pc = Dのようなもの、またはそのようなものを言うことができます。 
つまり、メモリアドレスpcにあるものは何でも、 

Dutch: 
 is dat de naam van een array eigenlijk een aanwijzer is 
 naar het eerste element van die array. 
 >> OK dus nu we al deze feiten hebben, laten we doorgaan, goed. 
 Waarom maakt het ons uit waar iets leeft. 
 Zoals ik al zei, het is best handig om te weten waar iets leeft 
 zodat u daarheen kunt gaan en het kunt wijzigen. 
 Werk ermee en heb echt het ding dat je hebt 
 willen dat die variabele effect heeft, en niet van kracht worden op een kopie ervan. 
 Dit wordt dereferentie genoemd. 
 We gaan naar de referentie en we veranderen de waarde daar. 
 Dus als we een aanwijzer hebben die pc heet en die naar een personage verwijst, 
 dan kunnen we zeggen * pc en * pc is de naam van wat we zullen vinden als we gaan 
 naar het adres pc. 
 Wat we daar zullen vinden, is een teken en * pc is hoe we daarbij naar de gegevens verwijzen 
 plaats. 
 Dus we zouden zoiets als * pc = D of iets dergelijks kunnen zeggen, 
 en dat betekent dat wat er ook op geheugenadres pc stond, 

Indonesian: 
 adalah bahwa nama array sebenarnya adalah sebuah pointer 
 ke elemen pertama array itu. 
 >> OK jadi sekarang kita memiliki semua fakta ini, mari kita lanjutkan, benar. 
 Mengapa kita peduli di mana sesuatu tinggal. 
 Seperti yang saya katakan, sangat berguna untuk mengetahui di mana sesuatu tinggal 
 sehingga Anda bisa pergi ke sana dan mengubahnya. 
 Bekerja dengannya dan benar-benar memiliki hal yang Anda inginkan 
 ingin lakukan untuk variabel itu berlaku, dan tidak berlaku pada beberapa salinannya. 
 Ini disebut dereferencing. 
 Kami pergi ke referensi dan kami mengubah nilainya di sana. 
 Jadi jika kita memiliki pointer dan itu disebut pc, dan itu menunjuk ke sebuah karakter, 
 maka kita dapat mengatakan * pc dan * pc adalah nama dari apa yang akan kita temukan jika kita pergi 
 ke pc alamat. 
 Apa yang akan kita temukan ada karakter dan * pc adalah bagaimana kita merujuk data pada saat itu 
 lokasi. 
 Jadi kita bisa mengatakan sesuatu seperti * pc = D atau sesuatu seperti itu, 
 dan itu berarti bahwa apa pun yang ada di pc alamat memori, 

English: 
is that the name of an array actually a pointer
to the first element of that array.
>> OK so now we have all these facts, let's keep going, right.
Why do we care about where something lives.
Well like I said, it's pretty useful to know where something lives
so you can go there and change it.
Work with it and actually have the thing that you
want to do to that variable take effect, and not take effect on some copy of it.
This is called dereferencing.
We go to the reference and we change the value there.
So if we have a pointer and it's called pc, and it points to a character,
then we can say *pc and *pc is the name of what we'll find if we go
to the address pc.
What we'll find there is a character and *pc is how we refer to the data at that
location.
So we could say something like *pc=D or something like that,
and that means that whatever was at memory address pc,

Portuguese: 
 é que o nome de uma matriz é realmente um ponteiro 
 para o primeiro elemento dessa matriz. 
 >> OK, então agora temos todos esses fatos, vamos continuar, certo. 
 Por que nos preocupamos com onde algo vive? 
 Bem, como eu disse, é muito útil saber onde algo mora 
 então você pode ir lá e mudar. 
 Trabalhe com ele e realmente tenha o que você 
 deseja fazer com que a variável entre em vigor e não entre em uma cópia dela. 
 Isso é chamado de desreferenciação. 
 Vamos para a referência e alteramos o valor lá. 
 Então, se temos um ponteiro e ele se chama pc, e aponta para um personagem, 
 então podemos dizer * pc e * pc é o nome do que encontraremos se formos 
 para o endereço pc. 
 O que descobriremos que existe um caractere e * pc é como nos referimos aos dados naquele 
 localização. 
 Então, poderíamos dizer algo como * pc = D ou algo assim, 
 e isso significa que o que quer que estivesse no endereço de memória pc, 

English: 
whatever character was previously there, is now D, if we say *pc=D.
>> So here we go again with some weird C stuff, right.
So we've seen * previously as being somehow part of the data type,
and now it's being used in a slightly different context
to access the data at a location.
I know it's a little confusing and that's actually part of this whole
like, why pointers have this mythology around them as being so complex,
is kind of a syntax problem, honestly.
But * is used in both contexts, both as part of the type name,
and we'll see a little later something else, too.
And right now is the dereference operator.
So it goes to the reference, it accesses the data
at the location of the pointer, and allows you to manipulate it at will.
>> Now this is very similar to visiting your neighbor, right.
If you know what your neighbor lives, you're
not hanging out with your neighbor.
You know you happen to know where they live,
but that doesn't mean that by virtue of having that knowledge
you are interacting with them.

Korean: 
 * pc = D라고 말하면 이전에 어떤 문자가 있었 든 이제 D입니다. 
 >> 그래서 여기서 우리는 이상한 C 재료로 다시갑니다. 
 이전에는 데이터 형식의 일부인 것으로 보았습니다. 
 이제는 약간 다른 맥락에서 사용되고 있습니다 
 위치의 데이터에 액세스합니다. 
 약간 혼란스럽고 실제로이 전체의 일부입니다 
 포인터가 왜 이런 신화를 둘러싼 복잡한 지, 
 솔직히 말해서 구문 문제입니다. 
 그러나 *는 두 가지 컨텍스트 모두에서 유형 이름의 일부로 사용됩니다. 
 그리고 나중에 또 다른 것을 보게 될 것입니다. 
 그리고 지금 역 참조 연산자입니다. 
 참조로 이동하여 데이터에 액세스합니다. 
 포인터의 위치에서 원하는대로 조작 할 수 있습니다. 
 >> 이것은 이웃을 방문하는 것과 매우 유사합니다. 
 이웃이 무엇을하는지 알고 있다면 
 이웃과 어울리지 않는 
 그들이 사는 곳을 알게된다면 
 그러나 그것이 그 지식을 가지고 있다는 것을 의미하지는 않습니다 
 당신은 그들과 상호 작용하고 있습니다. 

Indonesian: 
 karakter apa pun yang sebelumnya ada di sana, sekarang D, jika kita katakan * pc = D. 
 >> Jadi di sini kita kembali dengan beberapa hal aneh C, benar. 
 Jadi kita telah melihat * sebelumnya sebagai bagian dari tipe data, 
 dan sekarang ini digunakan dalam konteks yang sedikit berbeda 
 untuk mengakses data di suatu lokasi. 
 Saya tahu ini agak membingungkan dan itu sebenarnya bagian dari keseluruhan ini 
 seperti, mengapa petunjuk memiliki mitologi ini di sekitar mereka sebagai sangat kompleks, 
 adalah jenis masalah sintaksis, jujur. 
 Tapi * digunakan dalam kedua konteks, baik sebagai bagian dari nama jenis, 
 dan nanti kita akan melihat sesuatu yang lain juga. 
 Dan sekarang adalah operator dereference. 
 Jadi pergi ke referensi, mengakses data 
 di lokasi pointer, dan memungkinkan Anda untuk memanipulasi sesuka hati. 
 >> Sekarang ini sangat mirip dengan mengunjungi tetangga Anda, kan. 
 Jika Anda tahu apa tetangga Anda tinggal, Anda 
 tidak bergaul dengan tetangga Anda. 
 Anda tahu Anda kebetulan tahu di mana mereka tinggal, 
 tetapi itu tidak berarti bahwa berdasarkan memiliki pengetahuan itu 
 Anda berinteraksi dengan mereka. 

Japanese: 
 * pc = Dとすると、以前そこにあった文字はすべてDになります。 
 >>では、ここでまた奇妙なCのものを使います。 
したがって、*は以前、何らかの形でデータ型の一部であると見なしていました。 
そして今は少し異なる状況で使用されています
場所にあるデータにアクセスします。 
私はそれが少し混乱していることを知っています、そしてそれは実際にはこの全体の一部です
たとえば、ポインターがこの神話を非常に複雑であるとする理由は、 
正直なところ、一種の構文問題です。 
ただし、*は両方のコンテキストで、型名の一部として使用されます。 
少し後でまた別のものが表示されます。 
そして今は逆参照演算子です。 
参照に行き、データにアクセスします
ポインタの位置で、自由に操作できます。 
 >>これは、隣人を訪ねるのとよく似ています。 
あなたがあなたの隣人が住んでいるものを知っているなら、あなたは
隣人と付き合っていない。 
あなたはたまたま彼らがどこに住んでいるのかを知っています。 
しかし、それはその知識を持っているという理由で
あなたは彼らと交流しています。 

Chinese: 
如果我們說* pc = D，則以前存在的任何字符現在都是D。 
 >>因此，這裡我們再次介紹一些奇怪的C語言，對。 
因此，我們以前*已經將其視為數據類型的一部分， 
現在它在稍微不同的環境中使用
在某個位置訪問數據。 
我知道這有點令人困惑，實際上這是整個過程的一部分
例如，為什麼指針具有如此復雜的神話， 
老實說，這是一種語法問題。 
但是*在兩種情況下都使用*，它們都是類型名稱的一部分， 
我們稍後還會看到其他內容。 
現在是解除引用運算符。 
所以它去參考，它訪問數據
在指針的位置，並允許您隨意操作它。 
 >>現在，這非常類似於拜訪您的鄰居。 
如果您知道鄰居的生活，那麼您就是
不和你的鄰居閒逛。 
你知道你碰巧知道他們住在哪裡， 
但這並不意味著憑藉這些知識
您正在與他們互動。 

Spanish: 
 cualquier personaje que haya estado allí anteriormente, ahora es D, si decimos * pc = D. 
 >> Así que aquí vamos de nuevo con algunas cosas extrañas de C, correcto. 
 Así que hemos visto * anteriormente como parte del tipo de datos, 
 y ahora se usa en un contexto ligeramente diferente 
 para acceder a los datos en una ubicación. 
 Sé que es un poco confuso y que en realidad es parte de todo este 
 como, por qué los punteros tienen esta mitología a su alrededor como tan compleja, 
 Es una especie de problema de sintaxis, sinceramente. 
 Pero * se usa en ambos contextos, ambos como parte del nombre del tipo, 
 y veremos un poco más tarde algo más también. 
 Y en este momento es el operador de desreferencia. 
 Entonces va a la referencia, accede a los datos 
 en la ubicación del puntero, y le permite manipularlo a voluntad. 
 >> Ahora bien, esto es muy similar a visitar a tu vecino. 
 Si sabes lo que vive tu vecino, eres 
 No salir con tu vecino. 
 Sabes que sabes dónde viven, 
 pero eso no significa que en virtud de tener ese conocimiento 
 Estás interactuando con ellos. 

Dutch: 
 welk karakter er ook was, het is nu D, als we zeggen * pc = D. 
 >> Dus hier gaan we weer met wat rare C-dingen, toch. 
 Dus we hebben * eerder gezien als een of andere manier onderdeel van het gegevenstype, 
 en nu wordt het gebruikt in een iets andere context 
 om toegang te krijgen tot de gegevens op een locatie. 
 Ik weet dat het een beetje verwarrend is en dat maakt eigenlijk deel uit van dit geheel 
 zoals waarom aanwijzers deze mythologie om zich heen hebben als zo complex, 
 is eigenlijk een soort syntaxisprobleem. 
 Maar * wordt gebruikt in beide contexten, beide als onderdeel van de typenaam, 
 en we zullen even later ook iets anders zien. 
 En op dit moment is de dereferentie-operator. 
 Dus het gaat naar de referentie, het heeft toegang tot de gegevens 
 op de locatie van de aanwijzer en stelt u in staat deze naar believen te manipuleren. 
 >> Nu lijkt dit erg op het bezoeken van je buurman, toch. 
 Als je weet wat je buurman leeft, dan ben je dat 
 niet rondhangen met je buurman. 
 Je weet dat je toevallig weet waar ze wonen, 
 maar dat betekent niet dat op grond van die kennis 
 je hebt interactie met hen. 

Italian: 
 qualunque personaggio fosse precedentemente lì, ora è D, se diciamo * pc = D. 
 >> Quindi eccoci di nuovo con alcune strane cose in C, giusto. 
 Quindi abbiamo visto * precedentemente come in qualche modo parte del tipo di dati, 
 e ora viene utilizzato in un contesto leggermente diverso 
 per accedere ai dati in una posizione. 
 So che è un po 'confuso e che in realtà fa parte di tutto questo 
 tipo, perché i puntatori hanno intorno a loro questa mitologia così complessa, 
 è una specie di problema di sintassi, onestamente. 
 Ma * viene utilizzato in entrambi i contesti, entrambi come parte del nome del tipo, 
 e vedremo poco dopo anche qualcos'altro. 
 E in questo momento è l'operatore di dereference. 
 Quindi va al riferimento, accede ai dati 
 nella posizione del puntatore e ti consente di manipolarlo a piacimento. 
 >> Ora è molto simile a visitare il tuo vicino, giusto. 
 Se sai cosa vive il tuo vicino, lo sei 
 non uscire con il tuo vicino. 
 Sai che ti capita di sapere dove vivono, 
 ma ciò non significa che in virtù di quella conoscenza 
 stai interagendo con loro. 

Arabic: 
 أيا كانت الشخصية التي كانت موجودة من قبل ، فهي الآن D ، إذا قلنا * pc = D. 
 >> ها نحن نذهب مرة أخرى مع بعض الأشياء الغريبة C ، أليس كذلك. 
 لقد رأينا سابقًا * جزءًا من نوع البيانات بطريقة أو بأخرى ، 
 والآن يتم استخدامه في سياق مختلف قليلاً 
 للوصول إلى البيانات في موقع ما. 
 أعلم أنها مربكة بعض الشيء وهذا في الواقع جزء من هذا كله 
 مثل ، لماذا توجد مؤشرات حول هذه الأساطير حولها على أنها معقدة للغاية ، 
 هو نوع من مشكلة بناء الجملة ، بصراحة. 
 ولكن * يتم استخدامه في كلا السياقين ، كجزء من اسم النوع ، 
 وسنرى شيئًا آخر بعد ذلك أيضًا. 
 والآن هو عامل الإشارة. 
 لذلك يذهب إلى المرجع ، يصل إلى البيانات 
 في موقع المؤشر ، ويسمح لك بالتعامل معه كما تشاء. 
 >> الآن هذا مشابه جدًا لزيارة جارك ، صحيح. 
 إذا كنت تعرف ما يعيش جارك ، فأنت 
 لا تتسكع مع جارك. 
 أنت تعرف أنك تعرف أين يعيشون ، 
 لكن هذا لا يعني ذلك بحكم امتلاك هذه المعرفة 
 أنت تتفاعل معهم. 

Modern Greek (1453-): 
 οποιοσδήποτε χαρακτήρας ήταν προηγουμένως εκεί, είναι τώρα D, αν λέμε * pc = D. 
 >> Και εδώ πηγαίνουμε πάλι με κάποια παράξενα πράγματα Γ, σωστά. 
 Έτσι έχουμε δει * προηγουμένως ως μέρος του τύπου δεδομένων, 
 και τώρα χρησιμοποιείται σε ένα ελαφρώς διαφορετικό πλαίσιο 
 για να έχετε πρόσβαση στα δεδομένα σε μια τοποθεσία. 
 Ξέρω ότι είναι λίγο συγκεχυμένη και αυτό είναι πραγματικά μέρος αυτού του συνόλου 
 γιατί οι δείκτες έχουν αυτή τη μυθολογία γύρω τους ως τόσο περίπλοκη, 
 είναι ένα είδος συντακτικό πρόβλημα, ειλικρινά. 
 Αλλά * χρησιμοποιείται και στα δύο πλαίσια, τόσο ως μέρος του ονόματος τύπου, 
 και θα δούμε λίγο αργότερα κάτι άλλο. 
 Και τώρα είναι ο χειριστής dereference. 
 Οπότε πηγαίνει στην αναφορά, αλλά έχει πρόσβαση στα δεδομένα 
 στη θέση του δείκτη και σας επιτρέπει να το χειριστείτε κατά βούληση. 
 >> Τώρα αυτό είναι πολύ παρόμοιο με την επίσκεψη του πλησίον σας, σωστά. 
 Αν ξέρεις τι ζει ο γείτονάς σου, είσαι 
 μην κρέμονται με τον πλησίον σας. 
 Ξέρετε ότι τυχαίνει να ξέρετε πού ζουν, 
 αλλά αυτό δεν σημαίνει ότι λόγω της γνώσης αυτής 
 αλληλεπιδράτε μαζί τους. 

Portuguese: 
 qualquer que fosse o personagem que existia anteriormente, agora é D, se dissermos * pc = D. 
 >> Então, aqui vamos nós novamente com algumas coisas estranhas em C, certo. 
 Portanto, vimos * anteriormente como parte do tipo de dados, 
 e agora está sendo usado em um contexto um pouco diferente 
 para acessar os dados em um local. 
 Eu sei que é um pouco confuso e isso faz parte de todo esse 
 tipo, por que os ponteiros têm essa mitologia ao seu redor como sendo tão complexa, 
 é um tipo de problema de sintaxe, honestamente. 
 Mas * é usado nos dois contextos, como parte do nome do tipo, 
 e veremos um pouco mais tarde também. 
 E agora é o operador de desreferência. 
 Então vai para a referência, acessa os dados 
 no local do ponteiro e permite manipulá-lo à vontade. 
 >> Agora isso é muito parecido com visitar seu vizinho, certo. 
 Se você sabe o que seu vizinho vive, você está 
 não sair com seu vizinho. 
 Você sabe que sabe onde eles moram, 
 mas isso não significa que, em virtude de ter esse conhecimento 
 você está interagindo com eles. 

Turkish: 
 * pc = D dersek, daha önce orada olan karakter ne olursa olsun, şimdi D'dir. 
 >> İşte biraz garip C şeyleri ile tekrar gidiyoruz, değil mi? 
 Daha önce * veri türünün bir parçası olduğunu gördük, 
 ve şimdi biraz farklı bir bağlamda kullanılıyor 
 bir konumdaki verilere erişmek için. 
 Biraz kafa karıştırıcı olduğunu biliyorum ve aslında bu bütünün bir parçası 
 örneğin, işaretçiler neden bu mitolojiyi bu kadar karmaşık olarak görüyorlar, 
 dürüst olmak gerekirse bir tür sözdizimi problemidir. 
 Ancak * her iki bağlamda da, hem tür adının bir parçası olarak kullanılır, 
 ve biraz sonra başka bir şey daha göreceğiz. 
 Ve şimdi dereference operatörü. 
 Yani referansa gidiyor, verilere erişiyor 
 ve işaretçiyi istediğiniz zaman değiştirmenize izin verir. 
 >> Bu şimdi komşunuzu ziyaret etmeye çok benziyor, değil mi? 
 Komşunun ne yaşadığını biliyorsan, 
 komşunuzla takılmamak. 
 Nerede yaşadıklarını biliyorsun biliyorsun, 
 ama bu, bu bilgiye sahip olmamız sayesinde 
 onlarla etkileşime giriyorsunuz. 

French: 
 quel que soit le caractère qui s'y trouvait auparavant, est maintenant D, si nous disons * pc = D. 
 >> Alors nous y revoilà avec des trucs C étranges, à droite. 
 Nous avons donc vu * précédemment comme faisant en quelque sorte partie du type de données, 
 et maintenant il est utilisé dans un contexte légèrement différent 
 pour accéder aux données à un emplacement. 
 Je sais que c'est un peu déroutant et cela fait en fait partie de cet ensemble 
 comme, pourquoi les pointeurs ont cette mythologie autour d'eux comme étant si complexe, 
 est une sorte de problème de syntaxe, honnêtement. 
 Mais * est utilisé dans les deux contextes, à la fois dans le cadre du nom de type, 
 et nous verrons un peu plus tard quelque chose d'autre aussi. 
 Et maintenant, c'est l'opérateur de déréférence. 
 Il va donc à la référence, il accède aux données 
 à l'emplacement du pointeur, et vous permet de le manipuler à volonté. 
 >> Maintenant, cela ressemble beaucoup à la visite de votre voisin, à droite. 
 Si vous savez ce que vit votre voisin, vous êtes 
 ne pas traîner avec votre voisin. 
 Vous savez que vous savez où ils vivent, 
 mais cela ne signifie pas qu'en vertu de cette connaissance 
 vous interagissez avec eux. 

German: 
 Was auch immer vorher dort war, ist jetzt D, wenn wir * pc = D sagen. 
 >> Also los geht's wieder mit ein paar seltsamen C-Sachen, richtig. 
 Wir haben also * zuvor als Teil des Datentyps gesehen. 
 und jetzt wird es in einem etwas anderen Kontext verwendet 
 um an einem Ort auf die Daten zuzugreifen. 
 Ich weiß, dass es ein bisschen verwirrend ist und das ist eigentlich ein Teil dieses Ganzen 
 wie, warum Zeiger diese Mythologie als so komplex um sich haben, 
 ist ehrlich gesagt eine Art Syntaxproblem. 
 Aber * wird in beiden Kontexten verwendet, beide als Teil des Typnamens. 
 und wir werden etwas später noch etwas anderes sehen. 
 Und im Moment ist der Dereferenzierungsoperator. 
 Also geht es zur Referenz, es greift auf die Daten zu 
 an der Position des Zeigers und ermöglicht es Ihnen, ihn nach Belieben zu manipulieren. 
 >> Nun, das ist dem Besuch Ihres Nachbarn sehr ähnlich, richtig. 
 Wenn Sie wissen, was Ihr Nachbar lebt, sind Sie 
 nicht mit deinem Nachbarn rumhängen. 
 Sie wissen, dass Sie zufällig wissen, wo sie leben, 
 aber das bedeutet nicht, dass man dieses Wissen besitzt 
 Sie interagieren mit ihnen. 

Chinese: 
如果我们说* pc = D，则以前存在的任何字符现在都是D。 
 >>因此，这里我们再次介绍一些奇怪的C语言，对。 
因此，我们以前*已经将其视为数据类型的一部分， 
现在它在稍微不同的环境中使用
在某个位置访问数据。 
我知道这有点令人困惑，实际上这是整个过程的一部分
例如，为什么指针具有如此复杂的神话， 
老实说，这是一种语法问题。 
但是*在两种情况下都使用*，它们都是类型名称的一部分， 
我们稍后还会看到其他内容。 
现在是解除引用运算符。 
所以它去参考，它访问数据
在指针的位置，并允许您随意操作它。 
 >>现在，这非常类似于拜访您的邻居。 
如果您知道邻居的生活，那么您就是
不和你的邻居闲逛。 
你知道你碰巧知道他们住在哪里， 
但这并不意味着凭借这些知识
您正在与他们互动。 

Russian: 
 какой бы символ не был раньше, теперь D, если мы говорим * pc = D. 
 >> Так что здесь мы снова идем с некоторыми странными вещами C, верно. 
 Итак, ранее мы видели * как-то часть типа данных, 
 и теперь он используется в несколько ином контексте 
 для доступа к данным в месте. 
 Я знаю, что это немного сбивает с толку, и это на самом деле является частью этого целого 
 например, почему указатели окружают эту мифологию столь сложной, 
 это какая-то проблема синтаксиса, если честно. 
 Но * используется в обоих контекстах, как часть имени типа, 
 и мы увидим чуть позже кое-что еще. 
 И прямо сейчас это оператор разыменования. 
 Так что идет к ссылке, это обращается к данным 
 в месте расположения указателя, и позволяет вам манипулировать им по желанию. 
 >> Теперь это очень похоже на посещение вашего соседа, верно. 
 Если вы знаете, чем живет ваш сосед, вы 
 не тусоваться с соседом. 
 Вы знаете, что знаете, где они живут, 
 но это не значит, что в силу наличия этого знания 
 Вы взаимодействуете с ними. 

Hindi: 
 जो भी चरित्र पहले था, अब डी है, अगर हम कहें * पीसी = डी। 
 >> तो यहाँ हम कुछ अजीब सी सामान के साथ फिर से जाते हैं, ठीक है। 
 इसलिए हमने * पहले देखा कि किसी तरह डेटा टाइप का हिस्सा है, 
 और अब इसे थोड़ा अलग संदर्भ में इस्तेमाल किया जा रहा है 
 किसी स्थान पर डेटा एक्सेस करने के लिए। 
 मुझे पता है कि यह थोड़ा भ्रमित करने वाला है और यह वास्तव में इस पूरे का हिस्सा है 
 जैसे, क्यों पॉइंटर्स के पास यह पौराणिक कथा है, जो इतनी जटिल है, 
 ईमानदारी से एक वाक्यविन्यास समस्या है। 
 लेकिन * दोनों संदर्भों में उपयोग किया जाता है, दोनों प्रकार के नाम के भाग के रूप में, 
 और हम थोड़ी देर बाद कुछ और देखेंगे। 
 और अभी डीरेफेरेंस ऑपरेटर है। 
 तो यह संदर्भ में जाता है, यह डेटा तक पहुंचता है 
 पॉइंटर के स्थान पर, और आपको इसे इच्छानुसार हेरफेर करने की अनुमति देता है। 
 >> अब यह आपके पड़ोसी के पास जाने के समान है, ठीक है। 
 यदि आपको पता है कि आपका पड़ोसी कैसा रहता है, तो आप 
 अपने पड़ोसी के साथ घूमना नहीं। 
 आप जानते हैं कि आप जानते हैं कि वे कहाँ रहते हैं, 
 लेकिन इसका मतलब यह नहीं है कि उस ज्ञान के होने से 
 आप उनके साथ बातचीत कर रहे हैं। 

Dutch: 
 Als je met ze wilt communiceren, moet je naar hun huis gaan, 
 je moet gaan waar ze wonen. 
 En als je dat eenmaal doet, kun je communiceren 
 met hen zoals je zou willen. 
 En net als bij variabelen, moet je naar hun adres gaan 
 als je ze wilt gebruiken, kun je het adres niet zomaar weten. 
 En de manier waarop u naar het adres gaat, is door * te gebruiken, de dereferentie-operator. 
 Wat denk je dat er gebeurt als we proberen een andere referentie te geven 
 een aanwijzer waarvan de waarde null is? 
 Bedenk dat de null-aanwijzer naar niets verwijst. 
 Dus als je niets probeert te herleiden of niets naar een adres gaat, 
 wat denk je dat er gebeurt? 
 Als je de segmentatiefout vermoedde, zou je gelijk hebben. 
 Als u een null-aanwijzer probeert te ontleden, 
 u lijdt aan een segmentatiefout. Maar wacht, 
 heb ik je niet gezegd dat als je niet gaat 
 om uw waarde van uw aanwijzer in te stellen op iets zinvols, 
 je moet instellen op null? 
 Ik deed het en eigenlijk is de segmentatiefout een soort goed gedrag. 
 >> Heeft u ooit een variabele gedeclareerd en de waarde ervan niet onmiddellijk toegewezen? 

Turkish: 
 Onlarla etkileşim kurmak istiyorsanız, evlerine gitmelisiniz, 
 yaşadıkları yere gitmek zorundasınız. 
 Ve bunu yaptıktan sonra, 
 Onlarla aynen istediğiniz gibi. 
 Ve değişkenlere benzer şekilde, adreslerine gitmeniz gerekir 
 onlarla etkileşim kurmak istiyorsanız, sadece adresi bilemezsiniz. 
 Ve adrese gitme şekliniz dereference operatörü * kullanmaktır. 
 Sence denememiz ve izin vermememiz durumunda ne olur 
 değeri null olan bir işaretçi? 
 Sıfır göstergesinin hiçbir şeye işaret etmediğini hatırlayın. 
 Yani hiçbir şey denemeye çalışırsanız veya bir adrese hiçbir şeye gitmezseniz, 
 sence ne olur? 
 Segmentasyon hatası tahmin ederseniz, haklı olacaksınız. 
 Boş gösterici kullanmayı denerseniz ve 
 segmentasyon hatası alıyorsunuz. Fakat bekle, 
 sana söylemedim mi, eğer gitmezsen 
 işaretçinizin değerini anlamlı bir şeye ayarlamak için, 
 null olarak ayarlamanız gerekir mi? 
 Ben yaptım ve aslında segmentasyon hatası iyi bir davranış. 
 >> Hiç bir değişken beyan ettiniz ve değerini hemen atamadınız mı? 

Chinese: 
如果要与他们互动，您必须去他们的房子， 
你必须去他们住的地方。 
然后，您就可以进行互动了
就像您想要的那样与他们在一起。 
同样，对于变量，您需要转到其地址
如果您想与他们互动，您不仅会知道地址。 
到达地址的方式是使用*，即解除引用运算符。 
如果我们尝试取消引用，您认为会发生什么
一个值为空的指针？ 
回想一下，空指针指向什么都没有。 
因此，如果您尝试不取消引用或不访问任何地址， 
您认为会发生什么？ 
好吧，如果您猜测分段错误，那将是对的。 
如果您尝试取消引用空指针， 
您遇到细分错误。可是等等， 
我不是告诉你，如果你不去
将您的指针值设置为有意义的内容， 
您应该设置为null？ 
我做到了，实际上，细分错误是一种良好的行为。 
 >>您是否曾经声明过变量并且没有立即为其赋值？ 

Hindi: 
 यदि आप उनके साथ बातचीत करना चाहते हैं, तो आपको उनके घर जाना होगा, 
 आपको उस जगह पर जाना होगा जहाँ वे रहते हैं। 
 और एक बार जब आप ऐसा कर लेते हैं, तो आप बातचीत कर सकते हैं 
 उनके साथ जैसा आप चाहते हैं। 
 और इसी तरह चर के साथ, आपको उनके पते पर जाने की आवश्यकता है 
 यदि आप उनसे बातचीत करना चाहते हैं, तो आप केवल पता नहीं बता सकते। 
 और जिस तरह से आप पते पर जाते हैं, उसका उपयोग करना है *, डिरेक्शन ऑपरेटर। 
 आपको क्या लगता है अगर हम कोशिश करते हैं और डेरेन्स करते हैं 
 एक सूचक जिसका मूल्य शून्य है? 
 स्मरण करो कि अशक्त सूचक कुछ नहीं की ओर इशारा करता है। 
 इसलिए यदि आप कुछ भी करने की कोशिश करते हैं या कुछ नहीं करते हैं, 
 आपको क्या लगता है? 
 यदि आपने विभाजन की गलती का अनुमान लगाया है, तो आप सही होंगे। 
 यदि आप कोशिश करते हैं और एक अशक्त सूचक को हटा देते हैं, 
 आपको एक विभाजन दोष है। लेकिन रुकें, 
 मैंने आपको नहीं बताया, कि अगर आप नहीं जा रहे हैं 
 अपने पॉइंटर के मूल्य को कुछ सार्थक करने के लिए, 
 आपको अशक्त करना चाहिए? 
 मैंने किया और वास्तव में विभाजन की गलती एक अच्छे व्यवहार की तरह है। 
 >> क्या आपने कभी एक चर घोषित किया है और इसका मूल्य तुरंत नहीं सौंपा है? 

Chinese: 
如果要與他們互動，您必須去他們的房子， 
你必須去他們住的地方。 
然後，您就可以進行互動了
就像您想要的那樣與他們在一起。 
同樣，對於變量，您需要轉到其地址
如果您想與他們互動，您不僅會知道地址。 
到達地址的方式是使用*，即解除引用運算符。 
如果我們嘗試取消引用，您認為會發生什麼
一個值為空的指針？ 
回想一下，空指針指向什麼都沒有。 
因此，如果您嘗試不取消引用或不訪問任何地址， 
您認為會發生什麼？ 
好吧，如果您猜測分段錯誤，那將是對的。 
如果您嘗試取消引用空指針， 
您遇到細分錯誤。可是等等， 
我不是告訴你，如果你不去
將您的指針值設置為有意義的內容， 
您應該設置為null？ 
我做到了，實際上，細分錯誤是一種良好的行為。 
 >>您是否曾經聲明過變量並且沒有立即為其賦值？ 

Indonesian: 
 Jika Anda ingin berinteraksi dengan mereka, Anda harus pergi ke rumah mereka, 
 kamu harus pergi ke tempat mereka tinggal. 
 Dan begitu Anda melakukannya, maka Anda dapat berinteraksi 
 dengan mereka seperti yang Anda inginkan. 
 Dan sama dengan variabel, Anda harus pergi ke alamatnya 
 jika Anda ingin berinteraksi, Anda tidak bisa hanya mengetahui alamatnya. 
 Dan cara Anda pergi ke alamat adalah menggunakan *, operator dereference. 
 Menurut Anda apa yang terjadi jika kita mencoba dan merenung 
 pointer yang nilainya nol? 
 Ingat bahwa pointer nol menunjuk ke tidak ada. 
 Jadi jika Anda mencoba dan tidak melakukan referensi apa pun atau pergi ke alamat apa pun, 
 menurutmu apa yang terjadi? 
 Nah, jika Anda menebak kesalahan segmentasi, Anda akan benar. 
 Jika Anda mencoba dan melakukan referensi pointer nol, 
 Anda menderita kesalahan segmentasi. Tapi tunggu, 
 bukankah sudah saya katakan, bahwa jika Anda tidak pergi 
 untuk mengatur nilai pointer Anda ke sesuatu yang bermakna, 
 Anda harus mengatur ke nol? 
 Saya lakukan dan sebenarnya kesalahan segmentasi adalah jenis perilaku yang baik. 
 >> Apakah Anda pernah mendeklarasikan variabel dan tidak segera menetapkan nilainya? 

French: 
 Si vous voulez interagir avec eux, vous devez vous rendre chez eux, 
 vous devez aller là où ils vivent. 
 Et une fois que vous faites cela, vous pouvez interagir 
 avec eux comme vous le voudriez. 
 Et de même pour les variables, vous devez vous rendre à leur adresse 
 si vous voulez les interagir, vous ne pouvez pas simplement connaître l'adresse. 
 Et la façon dont vous allez à l'adresse est d'utiliser *, l'opérateur de déréférence. 
 Que pensez-vous qu'il se passe si nous essayons de déréférencer 
 un pointeur dont la valeur est nulle? 
 Rappelez-vous que le pointeur nul ne pointe vers rien. 
 Donc, si vous essayez de ne rien déréférencer ou d'aller à une adresse rien, 
 que pensez-vous qu'il se passe? 
 Eh bien, si vous avez deviné la faute de segmentation, vous auriez raison. 
 Si vous essayez de déréférencer un pointeur nul, 
 vous souffrez d'un défaut de segmentation. Mais attendez, 
 ne vous ai-je pas dit que si vous n'y allez pas 
 pour définir la valeur de votre pointeur sur quelque chose de significatif, 
 vous devez définir sur null? 
 Je l'ai fait et en fait, la faute de segmentation est une sorte de bon comportement. 
 >> Avez-vous déjà déclaré une variable sans lui avoir attribué immédiatement sa valeur? 

English: 
If you want to interact with them, you have to go to their house,
you have to go to where they live.
And once you do that, then you can interact
with them just like you'd want to.
And similarly with variables, you need to go to their address
if you want to interact them, you can't just know the address.
And the way you go to the address is to use *, the dereference operator.
What do you think happens if we try and dereference
a pointer whose value is null?
Recall that the null pointer points to nothing.
So if you try and dereference nothing or go to an address nothing,
what do you think happens?
Well if you guessed segmentation fault, you'd be right.
If you try and dereference a null pointer,
you suffer a segmentation fault. But wait,
didn't I tell you, that if you're not going
to set your value of your pointer to something meaningful,
you should set to null?
I did and actually the segmentation fault is kind of a good behavior.
>> Have you ever declared a variable and not assigned its value immediately?

Korean: 
 그들과 대화하고 싶다면 그들의 집으로 가야합니다 
 그들이 사는 곳으로 가야합니다. 
 일단 그렇게하면 상호 작용할 수 있습니다 
 당신이 원하는 것처럼 그들과 함께. 
 변수와 마찬가지로 주소로 이동해야합니다. 
 당신이 그들을 상호 작용하고 싶다면, 당신은 단지 주소를 알 수 없습니다. 
 주소로가는 방법은 역 참조 연산자 인 *를 사용하는 것입니다. 
 우리가 시도하고 역 참조하면 어떻게 될까요? 
 값이 null 인 포인터? 
 널 포인터가 아무것도 가리 키지 않음을 상기하십시오. 
 따라서 아무 것도 참조하지 않거나 주소를 지정하지 않으면 
 당신은 어떻게 생각하십니까? 
 세분화 오류를 추측했다면 옳을 것입니다. 
 널 포인터를 역 참조하려고하면 
 세분화 오류가 발생했습니다. 하지만 기다려, 
 내가 말하지 않았다면 
 포인터의 가치를 의미있는 것으로 설정하고 
 null로 설정해야합니까? 
 나는 실제로 세분화 오류는 좋은 행동입니다. 
 >> 변수를 선언하고 값을 즉시 할당하지 않은 적이 있습니까? 

Modern Greek (1453-): 
 Εάν θέλετε να αλληλεπιδράσετε με αυτούς, πρέπει να πάτε στο σπίτι τους, 
 πρέπει να πάτε όπου ζουν. 
 Και μόλις το κάνετε αυτό, τότε μπορείτε να αλληλεπιδράσετε 
 με αυτούς ακριβώς όπως θα θέλατε. 
 Και ομοίως με τις μεταβλητές, πρέπει να πάτε στη διεύθυνσή τους 
 αν θέλετε να τα αλληλεπιδράσετε, δεν μπορείτε απλώς να γνωρίζετε τη διεύθυνση. 
 Και ο τρόπος που πηγαίνετε στη διεύθυνση είναι να χρησιμοποιήσετε το *, τον χειριστή dereference. 
 Τι νομίζετε ότι συμβαίνει αν προσπαθήσουμε και την αποδυνάμωση 
 ένας δείκτης του οποίου η τιμή είναι null; 
 Θυμηθείτε ότι ο μηδενικός δείκτης δεν δείχνει τίποτα. 
 Έτσι, αν προσπαθήσετε και να μην κάνετε τίποτα ή να πάτε σε μια διεύθυνση τίποτα, 
 τι νομίζετε ότι συμβαίνει; 
 Λοιπόν, αν μαντέψατε σφάλμα κατάτμησης, θα έχετε δίκιο. 
 Αν προσπαθήσετε και dereference ένα μηδενικό δείκτη, 
 υποφέρετε από σφάλμα κατάτμησης. Αλλά περίμενε, 
 δεν σου είπα, ότι αν δεν πηγαίνεις 
 για να ορίσετε την αξία του δείκτη σας σε κάτι ουσιαστικό, 
 πρέπει να ορίσετε μηδέν; 
 Το έκανα και στην πραγματικότητα το σφάλμα κατάτμησης είναι μια καλή συμπεριφορά. 
 >> Έχετε δηλώσει ποτέ μια μεταβλητή και δεν έχει εκχωρηθεί η αξία της αμέσως; 

Arabic: 
 إذا كنت تريد التفاعل معهم ، فعليك الذهاب إلى منزلهم ، 
 عليك أن تذهب إلى حيث يعيشون. 
 وبمجرد القيام بذلك ، يمكنك التفاعل 
 معهم كما تريد. 
 وبالمثل مع المتغيرات ، تحتاج إلى الانتقال إلى عنوانها 
 إذا كنت تريد التفاعل معهم ، فلا يمكنك معرفة العنوان فقط. 
 والطريقة التي تنتقل بها إلى العنوان هي استخدام * ، عامل الإشارة. 
 ماذا يحدث في رأيك إذا حاولنا والإشارة 
 مؤشر قيمته فارغة؟ 
 تذكر أن المؤشر الفارغ يشير إلى لا شيء. 
 لذلك إذا حاولت عدم الإشارة إلى شيء أو ذهبت إلى عنوان لا شيء ، 
 ما رأيك يحدث؟ 
 حسنًا ، إذا خمنت خطأ التجزئة ، فستكون على حق. 
 إذا حاولت الإشارة إلى مؤشر فارغ ، 
 كنت تعاني من خطأ تجزئة. لكن انتظر، 
 ألم أخبرك ، إذا كنت لن تذهب 
 لتعيين قيمة المؤشر الخاص بك إلى شيء ذي مغزى ، 
 يجب عليك تعيين قيمة فارغة؟ 
 فعلت وفعلاً خطأ التقسيم هو نوع من السلوك الجيد. 
 >> هل سبق لك أن أعلنت عن متغير ولم تعين قيمته على الفور؟ 

German: 
 Wenn du mit ihnen interagieren willst, musst du zu ihrem Haus gehen, 
 du musst dorthin gehen, wo sie leben. 
 Und wenn Sie das getan haben, können Sie interagieren 
 mit ihnen genau so, wie du es willst. 
 Und ähnlich wie bei Variablen müssen Sie zu ihrer Adresse gehen 
 Wenn Sie mit ihnen interagieren möchten, können Sie nicht nur die Adresse kennen. 
 Um zur Adresse zu gelangen, verwenden Sie den Dereferenzierungsoperator *. 
 Was denkst du passiert, wenn wir versuchen zu dereferenzieren? 
 ein Zeiger, dessen Wert null ist? 
 Denken Sie daran, dass der Nullzeiger auf nichts zeigt. 
 Wenn Sie also versuchen, nichts zu dereferenzieren oder zu einer Adresse nichts zu gehen, 
 Was denkst du passiert? 
 Wenn Sie einen Segmentierungsfehler erraten haben, haben Sie Recht. 
 Wenn Sie versuchen, einen Nullzeiger zu dereferenzieren, 
 Sie haben einen Segmentierungsfehler. Aber warte, 
 Habe ich dir nicht gesagt, dass du nicht gehst? 
 um Ihren Wert Ihres Zeigers auf etwas Sinnvolles zu setzen, 
 Sie sollten auf null setzen? 
 Ich habe es getan und tatsächlich ist der Segmentierungsfehler ein gutes Verhalten. 
 >> Haben Sie jemals eine Variable deklariert und ihren Wert nicht sofort zugewiesen? 

Italian: 
 Se vuoi interagire con loro, devi andare a casa loro, 
 devi andare dove vivono. 
 E una volta che lo fai, allora puoi interagire 
 con loro proprio come vorresti. 
 E allo stesso modo con le variabili, devi andare al loro indirizzo 
 se vuoi interagire con loro, non puoi semplicemente conoscere l'indirizzo. 
 E il modo in cui vai all'indirizzo è usare *, l'operatore di dereference. 
 Cosa pensi che accada se proviamo e dereference 
 un puntatore il cui valore è null? 
 Ricordiamo che il puntatore null non punta a nulla. 
 Quindi se provi a non dedurre nulla o vai a un indirizzo nulla, 
 cosa pensi che accada? 
 Bene, se hai indovinato un errore di segmentazione, avresti ragione. 
 Se provi a dereferenziare un puntatore nullo, 
 soffri di un errore di segmentazione. Ma aspetta, 
 non te l'ho detto, se non ci andrai 
 per impostare il valore del puntatore su qualcosa di significativo, 
 dovresti impostare su null? 
 L'ho fatto e in realtà l'errore di segmentazione è un po 'un buon comportamento. 
 >> Hai mai dichiarato una variabile e non ne hai assegnato immediatamente il valore? 

Russian: 
 Если вы хотите общаться с ними, вы должны пойти в их дом, 
 Вы должны идти туда, где они живут. 
 И как только вы это сделаете, то вы можете взаимодействовать 
 с ними так же, как вы хотели бы. 
 И аналогично с переменными нужно перейти по их адресу 
 если вы хотите взаимодействовать с ними, вы не можете просто знать адрес. 
 И способ, которым вы идете по адресу, заключается в использовании *, оператора разыменования. 
 Как вы думаете, что произойдет, если мы попытаемся разыменовать 
 указатель с нулевым значением? 
 Напомним, что нулевой указатель указывает на ничто. 
 Так что, если вы попытаетесь ничего разыменовать или перейти на адрес ничего, 
 как вы думаете, что происходит? 
 Ну, если вы догадались, что ошибка сегментации, вы были бы правы. 
 Если вы попытаетесь разыменовать нулевой указатель, 
 Вы страдаете от ошибки сегментации. Но ждать, 
 разве я не говорил вам, что если вы не собираетесь 
 установить значение вашего указателя на что-то значимое, 
 Вы должны установить на ноль? 
 Я сделал, и на самом деле ошибка сегментации вроде хорошего поведения. 
 >> Вы когда-нибудь объявляли переменную и не присваивали ее значение сразу? 

Portuguese: 
 Se você quer interagir com eles, precisa ir à casa deles, 
 você tem que ir para onde eles moram. 
 E quando você fizer isso, poderá interagir 
 com eles como você gostaria. 
 E da mesma forma com as variáveis, você precisa ir ao endereço delas 
 se você quiser interagir com eles, não pode simplesmente saber o endereço. 
 E a maneira como você acessa o endereço é usar *, o operador de desreferência. 
 O que você acha que acontece se tentarmos desreferenciar 
 um ponteiro cujo valor é nulo? 
 Lembre-se de que o ponteiro nulo não aponta para nada. 
 Portanto, se você tentar desreferenciar nada ou acessar um endereço nada, 
 o que você acha que acontece? 
 Bem, se você adivinhou uma falha de segmentação, estaria certo. 
 Se você tentar desreferenciar um ponteiro nulo, 
 você sofre uma falha de segmentação. Mas espere, 
 eu não te disse que se você não vai 
 para definir seu valor do ponteiro para algo significativo, 
 você deve definir como nulo? 
 Eu fiz e, na verdade, a falha de segmentação é um bom comportamento. 
 >> Você já declarou uma variável e não atribuiu seu valor imediatamente? 

Spanish: 
 Si quieres interactuar con ellos, tienes que ir a su casa, 
 tienes que ir a donde viven. 
 Y una vez que haces eso, puedes interactuar 
 con ellos como te gustaría. 
 Y de manera similar con las variables, debe ir a su dirección 
 si quieres interactuar con ellos, no puedes simplemente conocer la dirección. 
 Y la forma de ir a la dirección es usar *, el operador de desreferencia. 
 ¿Qué crees que sucede si tratamos de desreferenciar 
 un puntero cuyo valor es nulo? 
 Recuerde que el puntero nulo apunta a nada. 
 Entonces, si intentas desreferenciar nada o ir a una dirección nada, 
 que crees que pasa 
 Bueno, si adivinaste la falla de segmentación, estarías en lo cierto. 
 Si intenta desreferenciar un puntero nulo, 
 Sufres una falla de segmentación. Pero espera, 
 no te dije que si no ibas 
 para establecer el valor de su puntero en algo significativo, 
 deberías poner a nulo? 
 Lo hice y, en realidad, la falla de segmentación es un buen comportamiento. 
 >> ¿Alguna vez ha declarado una variable y no le ha asignado su valor de inmediato? 

Japanese: 
彼らと交流したいなら、彼らの家に行かなければなりません、 
あなたは彼らが住んでいる場所に行かなければなりません。 
そしてそれをしたら、あなたは相互作用することができます
あなたがしたいように彼らと一緒に。 
変数についても同様に、そのアドレスに移動する必要があります
それらをやり取りしたい場合は、アドレスだけを知ることはできません。 
そして、アドレスに移動する方法は、逆参照演算子である*を使用することです。 
私たちが逆参照しようとするとどうなると思いますか
値がnullのポインタ？ 
 nullポインターは何も指していないことを思い出してください。 
したがって、何も逆参照しないか、アドレスに何も移動しない場合、 
何が起こると思いますか？ 
まあ、セグメンテーション違反を推測した場合、あなたは正しいでしょう。 
 nullポインターを逆参照しようとすると、 
セグメンテーション違反が発生します。ちょっと待って、 
あなたが行かないなら
ポインタの値を意味のあるものに設定するには、 
 nullに設定する必要がありますか？ 
私はそうしました、そして実際にセグメンテーションフォールトは一種の良い振る舞いです。 
 >>変数を宣言し、その値をすぐに割り当てたことはありませんか？ 

Indonesian: 
 Jadi Anda hanya mengatakan int x; Anda tidak benar-benar menetapkannya untuk apa pun 
 dan kemudian dalam kode Anda, Anda mencetak nilai x, 
 masih belum menugaskannya untuk apa pun. 
 Seringkali Anda mendapatkan nol, tetapi kadang-kadang Anda 
 mungkin mendapatkan nomor acak, dan Anda tidak tahu dari mana asalnya. 
 Demikian pula, hal-hal dapat terjadi dengan pointer. 
 Ketika Anda mendeklarasikan pointer int * pk misalnya, 
 dan Anda tidak menetapkannya ke nilai, Anda mendapatkan empat byte untuk memori. 
 Apa pun empat byte memori yang sistem dapat 
 menemukan yang memiliki nilai yang berarti. 
 Dan mungkin sudah ada sesuatu di sana 
 tidak lagi dibutuhkan oleh fungsi lain, jadi Anda hanya perlu 
 data apa pun ada di sana. 
 >> Bagaimana jika Anda mencoba melakukan dereference beberapa alamat yang Anda tidak- ada 
 sudah byte dan informasi di sana, itu sekarang di pointer Anda. 
 Jika Anda mencoba dan merujuk pointer itu, Anda mungkin mengacaukan beberapa memori 
 Anda tidak bermaksud mengacaukan semuanya. 
 Dan sebenarnya Anda bisa melakukan sesuatu yang sangat menghancurkan, 
 seperti merusak program lain, atau merusak fungsi lain, 
 atau melakukan sesuatu yang jahat yang tidak ingin Anda lakukan sama sekali. 

Arabic: 
 إذاً أنت فقط تقول int x ؛ لم تقم بتعيينه لأي شيء 
 ثم بعد ذلك في الكود الخاص بك ، تطبع قيمة x ، 
 حتى الآن لم يتم تعيينه لأي شيء. 
 في كثير من الأحيان تحصل على صفر ، ولكن في بعض الأحيان 
 قد تحصل على رقم عشوائي ، وليس لديك فكرة من أين أتى. 
 وبالمثل يمكن أن تحدث الأشياء مع المؤشرات. 
 عندما تعلن عن مؤشر int * pk على سبيل المثال ، 
 ولا تقوم بتعيينه لقيمة ، تحصل على أربعة بايت للذاكرة. 
 مهما كان أربعة بايت من الذاكرة يمكن للنظام 
 تجد أن لها قيمة ذات مغزى. 
 وربما كان هناك شيء موجود بالفعل 
 لم تعد هناك حاجة إليه بواسطة وظيفة أخرى ، لذلك لديك فقط 
 مهما كانت البيانات الموجودة هناك. 
 >> ماذا لو حاولت القيام بإحالة بعض العناوين التي لم تكن - هناك 
 بالفعل البايت والمعلومات الموجودة هناك ، وهي الآن في المؤشر الخاص بك. 
 إذا جربت هذا المؤشر وأعادت الإشارة إليه ، فقد تعبث ببعض الذاكرة 
 أنك لا تنوي العبث بها كلها. 
 وفي الحقيقة يمكنك أن تفعل شيئًا مدمرًا حقًا ، 
 مثل كسر برنامج آخر ، أو كسر وظيفة أخرى ، 
 أو القيام بشيء ضار لا تنوي القيام به على الإطلاق. 

German: 
 Sie sagen also einfach int x; Sie weisen es eigentlich nichts zu 
 und später in Ihrem Code drucken Sie den Wert von x aus, 
 immer noch nichts zugewiesen. 
 Häufig bekommst du Null, aber manchmal auch 
 Möglicherweise erhalten Sie eine Zufallszahl, und Sie haben keine Ahnung, woher sie stammt. 
 Ebenso können Dinge mit Zeigern passieren. 
 Wenn Sie beispielsweise einen Zeiger int * pk deklarieren, 
 und Sie weisen es keinem Wert zu, Sie erhalten vier Bytes für den Speicher. 
 Welche vier Bytes Speicher das System auch kann 
 finde, dass sie einen bedeutungsvollen Wert haben. 
 Und vielleicht war schon etwas da 
 wird von einer anderen Funktion nicht mehr benötigt, Sie haben also nur 
 welche Daten auch immer da waren. 
 >> Was wäre, wenn Sie versuchen würden, eine Adresse zu dereferenzieren, die Sie nicht haben? 
 bereits Bytes und Informationen drin, das ist jetzt in Ihrem Zeiger. 
 Wenn Sie versuchen, diesen Zeiger zu dereferenzieren, können Sie mit etwas Speicher herumspielen 
 dass du nicht vorhast, dich damit herumzuschlagen. 
 Und tatsächlich könnte man etwas wirklich Verheerendes tun, 
 wie ein anderes Programm brechen oder eine andere Funktion brechen, 
 oder etwas Bösartiges tun, das Sie überhaupt nicht vorhatten. 

Japanese: 
したがって、int xと言うだけです。実際には何にも割り当てません
その後、コードでxの値を出力します。 
まだ何にも割り当てていません。 
ゼロになることがよくありますが、 
乱数を取得する可能性があり、それがどこから来たかはわかりません。 
同様に、ポインターで事態が発生する可能性があります。 
たとえば、ポインタint * pkを宣言すると、 
それを値に割り当てない場合、メモリ用に4バイトを取得します。 
システムが実行できる4バイトのメモリ
いくつかの意味のある価値があることがわかります。 
そして、すでにそこに何かがあったかもしれません
別の関数で必要とされなくなったので、 
そこにあったどんなデータでも。 
 >>ないアドレスを逆参照しようとするとどうなるでしょう
そこにすでにバイトと情報があり、それは今あなたのポインタにあります。 
そのポインタを逆参照しようとすると、いくつかのメモリを混乱させている可能性があります
あなたはそれをすべて台無しにするつもりはなかったと。 
そして実際、あなたは本当に壊滅的な何かをすることができました、 
別のプログラムを壊したり、別の機能を壊したり
または、あなたがまったく行うつもりがなかった悪意のあることをします。 

Korean: 
 그래서 당신은 int x라고 말합니다; 당신은 실제로 그것을 아무것도 할당하지 않습니다 
 나중에 코드에서 x 값을 출력합니다. 
 아직 아무것도 할당하지 않았습니다. 
 자주 0을 얻지 만 때로는 
 임의의 숫자를 얻을 수 있으며 어디서 왔는지 모릅니다. 
 마찬가지로 포인터로 문제가 발생할 수 있습니다. 
 예를 들어 포인터를 int * pk로 선언하면 
 값에 할당하지 않으면 메모리에 4 바이트를 얻습니다. 
 시스템이 4 바이트의 메모리 용량 
 의미있는 가치가있는 것을 찾으십시오. 
 그리고 거기에 이미 무언가가 있었을 것입니다 
 더 이상 다른 기능에 필요하지 않으므로 
 모든 데이터가있었습니다. 
 >> 당신이하지 않은 주소를 역 참조하려고하면 어떻게해야합니까? 
 이미 바이트와 정보가 있습니다. 이제 포인터에 있습니다. 
 해당 포인터를 역 참조하면 메모리가 엉망이 될 수 있습니다. 
 당신이 그것을 엉망으로 만들 의도가 아니라는 것을. 
 실제로 당신은 정말 파괴적인 일을 할 수 있습니다. 
 다른 프로그램을 중단하거나 다른 기능을 중단하는 등 
 또는 의도하지 않은 악의적 인 행동을하는 것. 

Portuguese: 
 Então você acabou de dizer int x; na verdade, você não o atribui a nada 
 e, posteriormente, em seu código, você imprime o valor de x, 
 ainda não o atribuiu a nada. 
 Freqüentemente você recebe zero, mas às vezes você 
 pode obter um número aleatório e você não tem ideia de onde ele veio. 
 Da mesma forma, as coisas podem acontecer com ponteiros. 
 Quando você declara um ponteiro int * pk, por exemplo, 
 e você não o atribui a um valor, obtém quatro bytes de memória. 
 Quaisquer que sejam os quatro bytes de memória que o sistema possa 
 achar que tem algum valor significativo. 
 E talvez já houvesse algo lá que 
 não é mais necessário para outra função, então você só tem 
 quaisquer dados que existissem. 
 >> E se você tentasse desferir algum endereço que não - havia 
 já bytes e informações, agora estão no seu ponteiro. 
 Se você tentar desreferenciar esse ponteiro, talvez esteja mexendo com alguma memória 
 que você não pretendia mexer com tudo. 
 E na verdade você poderia fazer algo realmente devastador, 
 como quebrar outro programa ou quebrar outra função, 
 ou faça algo malicioso que você não pretendia fazer. 

Spanish: 
 Entonces solo dices int x; en realidad no lo asignas a nada 
 y luego en su código, imprime el valor de x, 
 sin haberlo asignado aún a nada. 
 Con frecuencia obtendrá cero, pero a veces usted 
 podría obtener un número aleatorio, y no tienes idea de dónde vino. 
 Del mismo modo, pueden suceder cosas con punteros. 
 Cuando declaras un puntero int * pk por ejemplo, 
 y no lo asigna a un valor, obtiene cuatro bytes para la memoria. 
 Cualesquiera cuatro bytes de memoria que el sistema pueda 
 encontrar que tienen algún valor significativo. 
 Y podría haber algo ya allí que 
 otra función ya no lo necesita, por lo que solo tiene 
 cualquier dato que haya allí. 
 >> ¿Qué pasaría si intentara desreferenciar alguna dirección que no conoce? 
 Ya hay bytes e información allí, eso está ahora en su puntero. 
 Si intenta desreferenciar ese puntero, puede estar jugando con algo de memoria 
 que no pretendías meterte con todo. 
 Y de hecho podrías hacer algo realmente devastador, 
 como romper otro programa, o romper otra función, 
 o hacer algo malicioso que no pretendías hacer en absoluto. 

Hindi: 
 तो आप सिर्फ int x कहते हैं; आप वास्तव में इसे कुछ भी असाइन नहीं करते हैं 
 और फिर बाद में आपके कोड में, आप x का मान प्रिंट करते हैं, 
 अभी भी इसे कुछ भी नहीं सौंपा है। 
 बार-बार आपको शून्य मिलेगा, लेकिन कभी-कभी आप 
 कुछ यादृच्छिक संख्या मिल सकती है, और आपको पता नहीं है कि यह कहाँ से आया है। 
 इसी तरह पॉइंटर्स के साथ चीजें हो सकती हैं। 
 जब आप उदाहरण के लिए एक सूचक int * pk घोषित करते हैं, 
 और आप इसे किसी मूल्य पर असाइन नहीं करते हैं, आपको मेमोरी के लिए चार बाइट्स मिलते हैं। 
 स्मृति चार बाइट्स जो भी सिस्टम कर सकता है 
 पाते हैं कि कुछ सार्थक मूल्य है। 
 और हो सकता है कि वहाँ पहले से ही कुछ था 
 अब किसी अन्य फ़ंक्शन की आवश्यकता नहीं है, इसलिए आपके पास बस है 
 जो भी डेटा था। 
 >> यदि आपने कुछ पता करने की कोशिश की है जो आपके पास नहीं है, तो आप थे 
 वहां पहले से ही बाइट्स और जानकारी है, जो अब आपके पॉइंटर में है। 
 यदि आप कोशिश करते हैं और उस सूचक को निष्क्रिय करते हैं, तो आप कुछ स्मृति के साथ खिलवाड़ कर सकते हैं 
 कि तुम यह सब के साथ गड़बड़ करने का इरादा नहीं था। 
 और वास्तव में आप वास्तव में विनाशकारी कुछ कर सकते हैं, 
 जैसे किसी अन्य प्रोग्राम को तोड़ें, या दूसरे फ़ंक्शन को तोड़ें, 
 या ऐसा कोई दुर्भावनापूर्ण काम करें जो आप बिल्कुल नहीं करना चाहते। 

English: 
So you just say int x; you don't actually assign it to anything
and then later on in your code, you print out the value of x,
having still not assigned it to anything.
Frequently you'll get zero, but sometimes you
might get some random number, and you have no idea where it came from.
Similarly can things happen with pointers.
When you declare a pointer int*pk for example,
and you don't assign it to a value, you get four bytes for memory.
Whatever four bytes of memory the system can
find that have some meaningful value.
And there might have been something already there that
is no longer needed by another function, so you just have
whatever data was there.
>> What if you tried to do dereference some address that you don't- there were
already bytes and information in there, that's now in your pointer.
If you try and dereference that pointer, you might be messing with some memory
that you didn't intend to mess with it all.
And in fact you could do something really devastating,
like break another program, or break another function,
or do something malicious that you didn't intend to do at all.

Turkish: 
 Yani sadece int x; aslında hiçbir şeye atamazsın 
 ve daha sonra kodunuzda, x değerini yazdırırsınız, 
 hala hiçbir şeye atamamıştı. 
 Sık sık sıfır alırsınız, ancak bazen 
 rastgele bir sayı alabilir ve nereden geldiğine dair hiçbir fikriniz yoktur. 
 Benzer şekilde işaretçilerle de bir şeyler olabilir. 
 Örneğin bir işaretçi int * pk bildirdiğinizde, 
 ve bir değere atamazsanız, bellek için dört bayt alırsınız. 
 Sistemin dört bayt belleği ne olursa olsun 
 bazı anlamlı değeri olan bul. 
 Ve orada zaten bir şey olmuş olabilir 
 artık başka bir işlev için gerekli değildir, 
 orada ne veri varsa. 
 >> Olmadığınız bazı adresleri iptal etmeye çalıştıysanız, 
 Zaten bayt ve bilgi var, bu şimdi işaretçinizde. 
 Bu işaretçiyi kaldırmaya çalışırsanız, biraz bellekle uğraşıyor olabilirsiniz 
 her şeyi karıştırmak istemediniz. 
 Aslında gerçekten yıkıcı bir şey yapabilirsiniz, 
 başka bir programı kırmak veya başka bir işlevi kırmak gibi, 
 ya da hiç yapmak istemediğiniz kötü amaçlı bir şey yapın. 

Chinese: 
所以你只说int x;你实际上并没有将它分配给任何东西
然后在您的代码中，打印出x的值， 
还没有分配给任何东西。 
通常，您会得到零，但有时您会
可能会得到一些随机数，而您不知道它来自何处。 
指针也会发生类似的情况。 
例如，当您声明一个指针int * pk时， 
并且不将其分配给值，则会获得四个字节的内存。 
无论系统可以使用四个字节的内存
发现它们具有一些有意义的价值。 
而且可能已经有一些东西
不再需要其他功能，因此您只需
那里有什么数据。 
 >>如果您尝试取消引用某些您没有的地址怎么办？ 
里面已经有字节和信息了，现在就在您的指针中。 
如果尝试取消引用该指针，则可能会弄乱一些内存
你不想弄乱这一切。 
实际上，您可以做一些真正具有破坏性的事情， 
比如破坏另一个程序，或者破坏另一个功能， 
或者做一些您根本不打算做的恶意事情。 

French: 
 Donc, vous dites simplement int x; vous ne l'attribuez en fait à rien 
 puis plus tard dans votre code, vous imprimez la valeur de x, 
 ne l'ayant toujours assigné à rien. 
 Vous obtiendrez souvent zéro, mais parfois vous 
 peut obtenir un nombre aléatoire, et vous ne savez pas d'où il vient. 
 De même, des choses peuvent arriver avec des pointeurs. 
 Lorsque vous déclarez un pointeur int * pk par exemple, 
 et vous ne l'affectez pas à une valeur, vous obtenez quatre octets pour la mémoire. 
 Quels que soient les quatre octets de mémoire que le système peut 
 trouver qui ont une valeur significative. 
 Et il y avait peut-être déjà quelque chose 
 n'est plus nécessaire à une autre fonction, il vous suffit donc 
 quelles que soient les données. 
 >> Et si vous essayiez de déréférencer une adresse que vous n'avez pas - il y avait 
 déjà des octets et des informations là-dedans, c'est maintenant dans votre pointeur. 
 Si vous essayez de déréférencer ce pointeur, vous risquez de jouer avec de la mémoire 
 que vous n'aviez pas l'intention de tout gâcher. 
 Et en fait, vous pourriez faire quelque chose de vraiment dévastateur, 
 comme casser un autre programme, ou casser une autre fonction, 
 ou faire quelque chose de malveillant que vous n'aviez pas du tout l'intention de faire. 

Dutch: 
 Dus je zegt gewoon int x; je wijst het eigenlijk nergens aan toe 
 en dan druk je later in je code de waarde van x af, 
 nog steeds nergens aan toegewezen. 
 Vaak krijg je nul, maar soms jij 
 kan een willekeurig getal krijgen en u heeft geen idee waar het vandaan komt. 
 Evenzo kunnen dingen gebeuren met pointers. 
 Wanneer u bijvoorbeeld een pointer int * pk declareert, 
 en je wijst het niet toe aan een waarde, je krijgt vier bytes voor geheugen. 
 Welke vier bytes geheugen het systeem ook kan 
 vind dat een betekenisvolle waarde heeft. 
 En misschien was er al iets dat dat was 
 is niet langer nodig door een andere functie, dus je hebt gewoon 
 welke gegevens er ook waren. 
 >> Wat als je een adres probeert te verwijten dat je niet hebt - dat waren er 
 al bytes en informatie daarin, dat staat nu in uw aanwijzer. 
 Als je die aanwijzer probeert te herleiden, rommel je misschien met wat geheugen 
 dat je niet van plan was ermee te rotzooien. 
 En in feite zou je iets heel verwoestends kunnen doen, 
 zoals een ander programma breken of een andere functie breken, 
 of doe iets kwaadaardigs dat je helemaal niet van plan was te doen. 

Russian: 
 Так что вы просто говорите Int X; вы на самом деле ничего не назначаете 
 а затем в вашем коде вы распечатываете значение х, 
 все еще не назначив это ни на что. 
 Часто вы получите ноль, но иногда вы 
 может получить какое-то случайное число, и вы не знаете, откуда оно. 
 Точно так же могут происходить вещи с указателями. 
 Когда вы объявляете указатель int * pk, например, 
 и вы не присваиваете ему значение, вы получаете четыре байта для памяти. 
 Какие бы четыре байта памяти система не могла 
 найти, что имеют какое-то значимое значение. 
 И там уже могло быть что-то, что 
 больше не нужна другой функции, так что вы просто 
 какие бы данные не были там. 
 >> Что делать, если вы пытаетесь разыменовать какой-то адрес, который вы не - там были 
 там уже есть байты и информация, теперь это указатель. 
 Если вы попытаетесь разыменовать этот указатель, возможно, вы запутались в памяти 
 что ты не собирался возиться со всем этим. 
 И на самом деле вы могли бы сделать что-то действительно разрушительное, 
 как сломать другую программу или сломать другую функцию, 
 или сделать что-то злое, что вы не собирались делать вообще. 

Chinese: 
所以你只說int x;你實際上並沒有將它分配給任何東西
然後在您的代碼中，打印出x的值， 
還沒有分配給任何東西。 
通常，您會得到零，但有時您會
可能會得到一些隨機數，而您不知道它來自何處。 
指針也會發生類似的情況。 
例如，當您聲明一個指針int * pk時， 
並且不將其分配給值，則會獲得四個字節的內存。 
無論系統可以使用四個字節的內存
發現它們具有一些有意義的價值。 
而且可能已經有一些東西
不再需要其他功能，因此您只需
那裡有什麼數據。 
 >>如果您嘗試取消引用某些您沒有的地址怎麼辦？ 
裡面已經有字節和信息了，現在就在您的指針中。 
如果嘗試取消引用該指針，則可能會弄亂一些內存
你不想弄亂這一切。 
實際上，您可以做一些真正具有破壞性的事情， 
比如破壞另一個程序，或者破壞另一個功能， 
或者做一些您根本不打算做的惡意事情。 

Italian: 
 Quindi dici solo int x; in realtà non lo assegni a nulla 
 e successivamente nel tuo codice, stampi il valore di x, 
 non averlo ancora assegnato a nulla. 
 Spesso otterrai zero, ma a volte tu 
 potrebbe ottenere un numero casuale e non hai idea da dove provenga. 
 Allo stesso modo possono accadere cose con i puntatori. 
 Ad esempio, quando si dichiara un puntatore int * pk, 
 e non lo si assegna a un valore, si ottengono quattro byte per la memoria. 
 Qualunque siano i quattro byte di memoria il sistema può 
 scopri che hanno un valore significativo. 
 E potrebbe esserci già stato qualcosa di simile 
 non è più necessario a un'altra funzione, quindi è sufficiente 
 qualunque dato ci fosse. 
 >> E se provassi a fare la differenza in qualche indirizzo che non hai ... 
 già byte e informazioni lì, che è ora nel tuo puntatore. 
 Se provi a dereferenziare quel puntatore, potresti incasinare un po 'di memoria 
 che non avevi intenzione di rovinare tutto. 
 E infatti potresti fare qualcosa di veramente devastante, 
 come interrompere un altro programma o interrompere un'altra funzione, 
 o fare qualcosa di dannoso che non intendevi fare affatto. 

Modern Greek (1453-): 
 Έτσι λέτε απλά int x; δεν το αναθέτετε σε τίποτα 
 και αργότερα στον κώδικα σας, εκτυπώνετε την τιμή του x, 
 έχοντας ακόμα δεν το έχει αναθέσει σε τίποτα. 
 Συχνά θα έχετε μηδέν, αλλά μερικές φορές εσείς 
 μπορεί να πάρει κάποιο τυχαίο αριθμό, και δεν έχετε ιδέα από πού προήλθε. 
 Ομοίως, τα πράγματα μπορούν να συμβούν με τους δείκτες. 
 Όταν δηλώνετε έναν δείκτη int * pk για παράδειγμα, 
 και δεν το αντιστοιχίζετε σε μια τιμή, παίρνετε τέσσερα byte για μνήμη. 
 Όποια και αν είναι τα τέσσερα byte μνήμης του συστήματος 
 βρίσκουν ότι έχουν κάποια σημαντική αξία. 
 Και μπορεί να υπήρχε κάτι ήδη εκεί 
 δεν χρειάζεται πλέον άλλη λειτουργία, έτσι έχετε ακριβώς 
 ανεξάρτητα από τα δεδομένα που υπήρχαν. 
 >> Τι γίνεται αν προσπαθήσατε να κάνετε αποτυχία με κάποια διεύθυνση που δεν υπήρχε; 
 ήδη bytes και πληροφορίες εκεί, αυτό είναι τώρα στο δείκτη σας. 
 Εάν προσπαθήσετε και αποδείξετε αυτόν τον δείκτη, ίσως να μπερδέψετε με κάποια μνήμη 
 ότι δεν σκοπεύατε να τα χρειαστείτε. 
 Και στην πραγματικότητα θα μπορούσατε να κάνετε κάτι πραγματικά καταστροφικό, 
 όπως να σπάσει ένα άλλο πρόγραμμα ή να σπάσει άλλη λειτουργία, 
 ή να κάνετε κάτι κακόβουλο που δεν σκοπεύατε να κάνετε καθόλου. 

Italian: 
 Ed è per questo che in realtà è una buona idea 
 per impostare i puntatori su null se non li si imposta su qualcosa di significativo. 
 Probabilmente è meglio alla fine della giornata per il tuo programma 
 andare in crash quindi per fare qualcosa che rovina 
 un altro programma o un'altra funzione. 
 Tale comportamento è probabilmente ancora meno ideale del semplice crash. 
 Ed è per questo che in realtà è una buona abitudine 
 per iniziare a impostare i puntatori su null se non li si imposta 
 a un valore significativo immediatamente, un valore che conosci 
 e che puoi tranquillamente la dereferenza. 
 >> Quindi torniamo ora e diamo un'occhiata alla sintassi generale della situazione. 
 Se dico int * p ;, cosa ho appena fatto? 
 Quello che ho fatto è questo. 
 So che il valore di p è un indirizzo perché tutti i puntatori sono giusti 
 indirizzi. 
 Posso dedurre p usando l'operatore *. 
 In questo contesto qui, in cima al richiamo, il * è parte del tipo. 
 Int * è il tipo di dati. 
 Ma posso dereference p usando l'operatore *, 

Arabic: 
 وهذا هو السبب في أنها فكرة جيدة 
 لتعيين مؤشراتك على قيمة خالية إذا لم تضبطها على شيء ذي مغزى. 
 ربما يكون من الأفضل في نهاية اليوم لبرنامجك 
 لتحطمها بعد ذلك للقيام بشيء يفسد 
 برنامج آخر أو وظيفة أخرى. 
 ربما يكون هذا السلوك أقل مثالية من مجرد التصادم. 
 وهذا هو السبب في أنها عادة جيدة 
 للوصول إلى تعيين مؤشراتك على قيمة خالية إذا لم تقم بتعيينها 
 إلى قيمة ذات مغزى على الفور ، قيمة تعرفها 
 وأنه يمكنك بأمان أن تبتعد. 
 >> فلنرجع الآن ونلقي نظرة على الصيغة العامة للموقف. 
 إذا قلت int * p ؛ فماذا فعلت للتو؟ 
 ما فعلته هو هذا. 
 أعلم أن قيمة p هي عنوان لأن جميع المؤشرات فقط 
 عناوين. 
 أستطيع أن ألغي الإشارة باستخدام عامل التشغيل *. 
 في هذا السياق هنا ، في أعلى الصفحة ، يُعد الرمز * جزءًا من النوع. 
 Int * هو نوع البيانات. 
 ولكن بإمكاني الإشارة إلى استخدام عامل التشغيل * ، 

Japanese: 
だからこそ、それは実際に良い考えです
ポインタを意味のあるものに設定しない場合は、ポインタをnullに設定します。 
それはあなたのプログラムにとって一日の終わりにおそらく良いでしょう
クラッシュして何かが失敗する
別のプログラムまたは別の関数。 
その動作は、おそらくクラッシュするよりもさらに理想的ではありません。 
それが実際に良い習慣である理由です
ポインタを設定しない場合は、ポインタをnullに設定します
すぐに意味のある値、あなたが知っている値に
安全に逆参照できること。 
 >>では、ここに戻って、状況の全体的な構文を見てみましょう。 
 int * p;と言った場合、何をしただけですか？ 
私がやったことはこれです。 
すべてのポインターがちょうどであるので、pの値がアドレスであることを知っています
アドレス。 
 *演算子を使用してpを逆参照できます。 
ここでのこのコンテキストでは、最上位で*が型の一部であることを思い出してください。 
 Int *はデータ型です。 
しかし、*演算子を使用してpを逆参照できます。 

Dutch: 
 En daarom is het eigenlijk een goed idee 
 om uw aanwijzers op null in te stellen als u ze niet op iets zinvols instelt. 
 Aan het eind van de dag is het waarschijnlijk beter voor uw programma 
 om dan te crashen om iets te doen dat het verknalt 
 een ander programma of een andere functie. 
 Dat gedrag is waarschijnlijk nog minder ideaal dan alleen crashen. 
 En daarom is het eigenlijk een goede gewoonte 
 om in te gaan om uw aanwijzers op null in te stellen als u ze niet instelt 
 onmiddellijk naar een betekenisvolle waarde, een waarde die u kent 
 en dat je de dereferentie veilig kunt maken. 
 >> Dus laten we nu terugkomen en de algemene syntaxis van de situatie bekijken. 
 Als ik int * p; zeg, wat heb ik dan net gedaan? 
 Wat ik heb gedaan is dit. 
 Ik weet dat de waarde van p een adres is omdat alle verwijzingen juist zijn 
 adressen. 
 Ik kan p verwijzen met de operator *. 
 In deze context hier, helemaal bovenaan, is de * onderdeel van het type. 
 Int * is het gegevenstype. 
 Maar ik kan p herleiden met de * operator, 

Russian: 
 И вот почему это на самом деле хорошая идея 
 установить ваши указатели на ноль, если вы не установите их на что-то значимое. 
 Возможно, лучше в конце дня для вашей программы 
 чтобы потерпеть крах, чтобы сделать что-то, что испортило 
 другая программа или другая функция. 
 Такое поведение, вероятно, даже менее идеальное, чем просто сбой. 
 И вот почему это на самом деле хорошая привычка 
 чтобы установить ваши указатели на ноль, если вы не установите их 
 к значимому значению сразу, значение, которое вы знаете 
 и что вы можете безопасно разыскивать. 
 >> Итак, давайте вернемся сейчас и посмотрим на общий синтаксис ситуации. 
 Если я скажу int * p; что я только что сделал? 
 Что я сделал, так это 
 Я знаю, что значение p является адресом, потому что все указатели просто 
 адреса. 
 Я могу разыменовать p используя оператор *. 
 В этом контексте здесь, на самом верху, напомним, * является частью типа. 
 Int * - это тип данных. 
 Но я могу разыменовать р используя оператор *, 

Hindi: 
 और इसलिए यह वास्तव में एक अच्छा विचार है 
 यदि आप उन्हें कुछ सार्थक करने के लिए सेट नहीं करते हैं, तो अपने बिंदुओं को शून्य करने के लिए। 
 यह शायद आपके कार्यक्रम के लिए दिन के अंत में बेहतर है 
 फिर दुर्घटना के लिए यह कुछ ऐसा करने के लिए जो शिकंजा कसता है 
 एक अन्य कार्यक्रम या एक अन्य समारोह। 
 यह व्यवहार शायद सिर्फ दुर्घटनाग्रस्त होने से भी कम आदर्श है। 
 और इसलिए यह वास्तव में एक अच्छी आदत है 
 यदि आप उन्हें सेट नहीं करते हैं, तो अपने बिंदुओं को शून्य करने के लिए सेट करें 
 एक सार्थक मूल्य तुरंत, एक मूल्य जिसे आप जानते हैं 
 और यह कि आप सुरक्षित रूप से रक्षा कर सकते हैं। 
 >> तो चलो अब वापस आते हैं और स्थिति के समग्र सिंटैक्स पर एक नज़र डालते हैं। 
 अगर मैं int * p कहूं, तो मैंने अभी क्या किया है? 
 मैंने जो किया है वह यही है। 
 मुझे पता है कि पी का मूल्य एक पता है क्योंकि सभी संकेत बस हैं 
 पतों। 
 मैं * ऑपरेटर का उपयोग करते हुए पी को डीरेक्शन कर सकता हूं। 
 यहाँ इस संदर्भ में, बहुत ऊपर याद है * प्रकार का हिस्सा है। 
 Int * डेटा प्रकार है। 
 लेकिन मैं * ऑपरेटर का उपयोग करते हुए पी को डीरेफर कर सकता हूं, 

Indonesian: 
 Dan itulah mengapa itu sebenarnya ide yang bagus 
 untuk mengatur pointer Anda ke nol jika Anda tidak mengaturnya ke sesuatu yang bermakna. 
 Mungkin lebih baik di akhir hari untuk program Anda 
 untuk crash maka untuk melakukan sesuatu yang mengacaukan 
 program lain atau fungsi lain. 
 Perilaku itu mungkin bahkan kurang ideal daripada hanya menabrak. 
 Dan itulah mengapa itu sebenarnya kebiasaan yang baik 
 untuk masuk ke mengatur pointer Anda ke nol jika Anda tidak mengaturnya 
 ke nilai yang bermakna segera, nilai yang Anda tahu 
 dan bahwa Anda dapat dengan aman dereference. 
 >> Jadi mari kita kembali sekarang dan melihat sintaks keseluruhan dari situasi ini. 
 Jika saya mengatakan int * p ;, apa yang baru saja saya lakukan? 
 Apa yang saya lakukan adalah ini. 
 Saya tahu nilai p adalah alamat karena semua petunjuknya adil 
 alamat. 
 Saya dapat dereferensi p menggunakan operator *. 
 Dalam konteks ini di sini, di paling atas ingat * adalah bagian dari tipe. 
 Int * adalah tipe data. 
 Tapi saya bisa dereferensi p menggunakan operator *, 

Korean: 
 그래서 이것이 실제로 좋은 생각 인 이유입니다 
 의미있는 것으로 설정하지 않으면 포인터를 null로 설정합니다. 
 하루가 끝나면 프로그램이 더 나을 것입니다. 
 그런 다음 망치는 무언가를하기 위해 충돌 
 다른 프로그램이나 다른 기능. 
 그 행동은 아마도 충돌하는 것보다 덜 이상적 일 것입니다. 
 그래서 이것이 실제로 좋은 습관 인 이유입니다 
 포인터를 설정하지 않으면 포인터를 null로 설정합니다. 
 곧바로 의미있는 가치, 당신이 알고있는 가치 
 안전하게 역 참조 할 수 있습니다. 
 >> 이제 다시 돌아와서 상황의 전체 구문을 살펴 보겠습니다. 
 int * p;라고 말하면 방금 무엇을 했습니까? 
 내가 한 것은 이것입니다. 
 모든 포인터가 그냥 있기 때문에 p의 값이 주소라는 것을 알고 있습니다. 
 구애. 
 * 연산자를 사용하여 p를 역 참조 할 수 있습니다. 
 이러한 맥락에서, 맨 위의 리콜에서 *는 유형의 일부입니다. 
 Int *는 데이터 유형입니다. 
 그러나 * 연산자를 사용하여 p를 역 참조 할 수 있습니다. 

Chinese: 
这就是为什么这实际上是一个好主意的原因
如果您没有将指针设置为有意义的值，则将其设置为null。 
在一天结束时，您的程序可能会更好
崩溃然后为它做一些弄糟的事情
另一个程序或另一个功能。 
这种行为可能比崩溃还不够理想。 
这就是为什么这实际上是一个好习惯
如果不设置指针，将其设置为null 
立即变成有意义的值，您知道的值
并且您可以放心取消引用。 
 >>因此，现在让我们返回来看一下这种情况的整体语法。 
如果我说int * p ;，我刚刚做了什么？ 
我所做的就是这个。 
我知道p的值是一个地址，因为所有指针都只是
地址。 
我可以使用*运算符取消引用p。 
在这种情况下，最上面的*是该类型的一部分。 
 Int *是数据类型。 
但是我可以使用*运算符取消引用p， 

Chinese: 
這就是為什麼這實際上是一個好主意的原因
如果您沒有將指針設置為有意義的值，則將其設置為null。 
在一天結束時，您的程序可能會更好
崩潰然後為它做一些弄糟的事情
另一個程序或另一個功能。 
這種行為可能比崩潰還不夠理想。 
這就是為什麼這實際上是一個好習慣
如果不設置指針，將其設置為null 
立即變成有意義的值，您知道的值
並且您可以放心取消引用。 
 >>因此，現在讓我們返回來看一下這種情況的整體語法。 
如果我說int * p ;，我剛剛做了什麼？ 
我所做的就是這個。 
我知道p的值是一個地址，因為所有指針都只是
地址。 
我可以使用*運算符取消引用p。 
在這種情況下，最上面的*是該類型的一部分。 
 Int *是數據類型。 
但是我可以使用*運算符取消引用p， 

French: 
 Et c'est pourquoi c'est en fait une bonne idée 
 pour définir vos pointeurs sur null si vous ne les définissez pas sur quelque chose de significatif. 
 C'est probablement mieux à la fin de la journée pour votre programme 
 planter alors pour qu'il fasse quelque chose qui fout 
 un autre programme ou une autre fonction. 
 Ce comportement est probablement encore moins idéal qu'un crash. 
 Et c'est pourquoi c'est une bonne habitude 
 entrer pour définir vos pointeurs sur null si vous ne les définissez pas 
 à une valeur significative immédiatement, une valeur que vous connaissez 
 et que vous pouvez en toute sécurité la déréférence. 
 >> Revenons donc maintenant et jetons un œil à la syntaxe globale de la situation. 
 Si je dis int * p ;, qu'est-ce que je viens de faire? 
 Voici ce que j'ai fait. 
 Je sais que la valeur de p est une adresse car tous les pointeurs sont juste 
 adresses. 
 Je peux déréférencer p en utilisant l'opérateur *. 
 Dans ce contexte, rappelez tout en haut que le * fait partie du type. 
 Int * est le type de données. 
 Mais je peux déréférencer p en utilisant l'opérateur *, 

German: 
 Deshalb ist es eigentlich eine gute Idee 
 um Ihre Zeiger auf null zu setzen, wenn Sie sie nicht auf etwas Sinnvolles setzen. 
 Am Ende des Tages ist es wahrscheinlich besser für Ihr Programm 
 dann abstürzen, damit es etwas tut, das es vermasselt 
 ein anderes Programm oder eine andere Funktion. 
 Dieses Verhalten ist wahrscheinlich noch weniger ideal als nur ein Absturz. 
 Und deshalb ist es eigentlich eine gute Angewohnheit 
 um Ihre Zeiger auf null zu setzen, wenn Sie sie nicht setzen 
 sofort zu einem sinnvollen Wert, einem Wert, den Sie kennen 
 und dass Sie sicher die Dereferenzierung können. 
 >> Kommen wir jetzt zurück und werfen einen Blick auf die Gesamtsyntax der Situation. 
 Wenn ich int * p; sage, was habe ich gerade getan? 
 Was ich getan habe ist das. 
 Ich weiß, dass der Wert von p eine Adresse ist, weil alle Zeiger gerecht sind 
 Adressen. 
 Ich kann p mit dem Operator * dereferenzieren. 
 In diesem Zusammenhang ist hier ganz oben das * Teil des Typs. 
 Int * ist der Datentyp. 
 Aber ich kann p mit dem Operator * dereferenzieren, 

English: 
And so that's why it's actually a good idea
to set your pointers to null if you don't set them to something meaningful.
It's probably better at the end of the day for your program
to crash then for it to do something that screws up
another program or another function.
That behavior is probably even less ideal than just crashing.
And so that's why it's actually a good habit
to get into to set your pointers to null if you don't set them
to a meaningful value immediately, a value that you know
and that you can safely the dereference.
>> So let's come back now and take a look at the overall syntax of the situation.
If I say int *p;, what have I just done?
What I've done is this.
I know the value of p is an address because all pointers are just
addresses.
I can dereference p using the * operator.
In this context here, at the very top recall the * is part of the type.
Int * is the data type.
But I can dereference p using the * operator,

Spanish: 
 Y por eso es una buena idea 
 para configurar sus punteros en nulo si no los configura en algo significativo. 
 Probablemente sea mejor al final del día para su programa 
 chocar para que haga algo que arruine 
 otro programa u otra función. 
 Ese comportamiento es probablemente incluso menos ideal que simplemente estrellarse. 
 Y por eso es un buen hábito 
 entrar para configurar sus punteros a nulos si no los configura 
 a un valor significativo de inmediato, un valor que conoces 
 y que puedes desreferenciar con seguridad. 
 >> Entonces volvamos ahora y echemos un vistazo a la sintaxis general de la situación. 
 Si digo int * p ;, ¿qué acabo de hacer? 
 Lo que he hecho es esto. 
 Sé que el valor de p es una dirección porque todos los punteros son solo 
 direcciones. 
 Puedo desreferenciar p usando el operador *. 
 En este contexto aquí, en la parte superior, recuerde que * es parte del tipo. 
 Int * es el tipo de datos. 
 Pero puedo desreferenciar p usando el operador *, 

Turkish: 
 Ve bu yüzden aslında iyi bir fikir 
 anlamlı bir şeye ayarlamazsanız, işaretçilerinizi null değerine ayarlamak için. 
 Muhtemelen günün sonunda programınız için daha iyi 
 çökmek için 
 başka bir program veya başka bir işlev. 
 Bu davranış muhtemelen çökmekten daha az idealdir. 
 Ve bu yüzden bu aslında iyi bir alışkanlık 
 ayarlamazsanız, işaretçilerinizi null değerine ayarlamak için 
 anlamlı bir değere, bildiğiniz bir değere 
 ve güvenle dereference yapabilirsiniz. 
 >> Şimdi geri dönelim ve durumun genel sözdizimine bir göz atalım. 
 İnt * p; dersem, az önce ne yaptım? 
 Yaptığım şey bu. 
 P değerinin bir adres olduğunu biliyorum çünkü tüm işaretçiler sadece 
 adresleri. 
 * Operatörünü kullanarak p dereference yapabilirim. 
 Burada bu bağlamda, en üstteki hatırlamada * türün bir parçasıdır. 
 Int * veri tipidir. 
 Ancak * operatörünü kullanarak p 

Modern Greek (1453-): 
 Και γι 'αυτό είναι πραγματικά μια καλή ιδέα 
 για να θέσετε τους δείκτες σας σε null, αν δεν τους ορίσετε κάτι ουσιαστικό. 
 Είναι πιθανώς καλύτερα στο τέλος της ημέρας για το πρόγραμμά σας 
 για να συντριβή στη συνέχεια για να κάνει κάτι που βίδες 
 ένα άλλο πρόγραμμα ή άλλη λειτουργία. 
 Αυτή η συμπεριφορά είναι ίσως ακόμη λιγότερο ιδανική από το να συντρίβεται. 
 Και γι 'αυτό είναι πραγματικά μια καλή συνήθεια 
 για να μπείτε στο να θέσετε τους δείκτες σας σε null, αν δεν τις ορίσετε 
 σε μια αξιόλογη αξία αμέσως, μια αξία που γνωρίζετε 
 και ότι μπορείτε με ασφάλεια να την αποδυνάμωση. 
 >> Ας επιστρέψουμε τώρα και να ρίξουμε μια ματιά στη συνολική σύνταξη της κατάστασης. 
 Αν λέω int * p ;, τι έκανα μόλις; 
 Αυτό που έχω κάνει είναι αυτό. 
 Ξέρω ότι η τιμή του p είναι μια διεύθυνση επειδή όλοι οι δείκτες είναι δίκαιοι 
 διευθύνσεις. 
 Μπορώ να dereference p χρησιμοποιώντας τον τελεστή *. 
 Σε αυτό το πλαίσιο εδώ, στην κορυφή της υπενθύμισης, το * είναι μέρος του τύπου. 
 Int * είναι ο τύπος δεδομένων. 
 Αλλά μπορώ να dereference p χρησιμοποιώντας τον χειριστή * 

Portuguese: 
 E é por isso que é realmente uma boa ideia 
 para definir seus ponteiros como nulos se você não os definir para algo significativo. 
 Provavelmente é melhor no final do dia para o seu programa 
 falhar, em seguida, para fazer algo que estraga tudo 
 outro programa ou outra função. 
 Esse comportamento é provavelmente ainda menos ideal do que apenas travar. 
 E é por isso que é realmente um bom hábito 
 entrar para definir seus ponteiros como nulos se você não os definir 
 para um valor significativo imediatamente, um valor que você conhece 
 e que você pode com segurança a desreferência. 
 >> Então, vamos voltar agora e dar uma olhada na sintaxe geral da situação. 
 Se eu disser int * p;, o que acabei de fazer? 
 O que eu fiz é isso. 
 Eu sei que o valor de p é um endereço, porque todos os ponteiros são apenas 
 endereços. 
 Posso desreferenciar p usando o operador *. 
 Neste contexto, aqui, no topo, lembre-se de que o * faz parte do tipo. 
 Int * é o tipo de dados. 
 Mas eu posso desreferenciar p usando o operador *, 

Turkish: 
 ve eğer yaparsam, o adrese gidersem, o adreste ne bulacağım? 
 Bir tamsayı bulacağım. 
 Yani int * p temelde p bir adrestir. 
 Ben p dereference olabilir ve eğer yaparsam, bir tamsayı bulacaksınız 
 o bellek konumunda. 
 >> Tamam, yıldızlarla başka bir can sıkıcı şey daha olduğunu söyledim 
 ve yıldızlarla ilgili bu sinir bozucu şey burada. 
 Hiç aynı türden birden çok değişken bildirmeye çalıştınız mı? 
 aynı kod satırında? 
 Yani bir saniye, çizgi, kodun aslında yeşil renkte olduğunu varsayalım 
 orada değil ve sadece int x, y, z; diyor. 
 Bunun için aslında sizin için üç tamsayı değişkeni yaratmak, 
 biri x, biri y ve biri z. 
 Bunu üç hatta bölmek zorunda kalmadan yapmanın bir yolu. 
 >> Burada yıldızlar yine can sıkıcı oluyor, 
 çünkü * aslında hem tür adının hem de bölümün bir parçasıdır 
 değişken adı. 
 Ve eğer int * px, py, pz dersem, aslında elde ettiğim tamsayıya bir işaretçi 

Japanese: 
その場合、その住所に行くと、その住所で何が見つかりますか？ 
整数を見つけます。 
つまり、int * pは基本的に、pはアドレスです。 
私はpを逆参照することができ、そうすると整数が見つかります
そのメモリ位置に。 
 >>わかりましたので、星にはもう迷惑があると言いました
そして、ここに星のある迷惑なものがあります。 
同じタイプの複数の変数を宣言しようとしたことがありますか
同じコード行に？ 
少しの間、その行をふりをして、私が実際にそこに持っているコードを緑色で
そこにはなく、単にint x、y、z;と表示されます。 
実際には、3つの整数変数を作成します。 
 xと呼ばれるもの、yと呼ばれるもの、zと呼ばれるもの。 
これは、3行に分割しなくても実行できる方法です。 
 >>ここでも、星が再び迷惑になります。 
 *は実際には型名と部分の両方の一部なので
変数名の。 
そして、私がint * px、py、pzと言った場合、実際に取得するのは整数へのポインタです

Korean: 
 그렇게하면, 그 주소로 가면 그 주소에서 무엇을 찾을 수 있습니까? 
 정수를 찾을 것입니다. 
 따라서 int * p는 기본적으로 p는 주소입니다. 
 나는 p를 역 참조 할 수 있으며 그렇게하면 정수를 찾을 수 있습니다 
 그 메모리 위치에서. 
 >> 좋아, 별과 함께 또 다른 성가신 말이 있다고 
 여기 별이있는 성가신 것이 있습니다. 
 같은 유형의 여러 변수를 선언하려고 시도한 적이 있습니까? 
 같은 코드 줄에? 
 그래서 잠깐 동안, 줄, 내가 실제로 가지고있는 코드를 척하십시오. 
 거기에 없으며 int x, y, z;라고 말합니다. 
 실제로는 3 개의 정수 변수를 만드는 것입니다. 
 하나는 x, 하나는 y, z는 z입니다. 
 세 줄로 나눌 필요없이 할 수있는 방법입니다. 
 >> 별이 다시 성가 시게되는 곳, 
 *는 실제로 유형 이름과 부분 모두의 일부이므로 
 변수 이름. 
 그래서 int * px, py, pz라고하면 실제로 얻는 것은 정수에 대한 포인터입니다. 

Spanish: 
 y si lo hago, si voy a esa dirección, ¿qué encontraré en esa dirección? 
 Encontraré un número entero. 
 Entonces int * p básicamente dice que p es una dirección. 
 Puedo desreferenciar p y si lo hago, encontraré un número entero 
 en esa ubicación de memoria. 
 >> OK, entonces dije que había otra cosa molesta con las estrellas 
 y aquí es donde está esa cosa molesta con las estrellas. 
 ¿Alguna vez ha tratado de declarar múltiples variables del mismo tipo? 
 en la misma línea de código? 
 Entonces, por un segundo, imagina que la línea, el código que realmente tengo allí en verde 
 no está allí y solo dice int x, y, z ;. 
 Lo que eso haría es crear tres variables enteras para usted, 
 uno llamado x, uno llamado y, y uno llamado z. 
 Es una forma de hacerlo sin tener que dividirse en tres líneas. 
 >> Aquí es donde las estrellas se vuelven molestas de nuevo, 
 porque el * es en realidad parte del nombre del tipo y parte 
 del nombre de la variable. 
 Entonces, si digo int * px, py, pz, lo que realmente obtengo es un puntero a un entero 

Hindi: 
 और अगर मैं ऐसा करता हूं, अगर मैं उस पते पर जाता हूं, तो मुझे उस पते पर क्या मिलेगा? 
 मुझे एक पूर्णांक मिलेगा। 
 तो int * p मूल रूप से कह रहा है, p एक पता है। 
 मैं पी को डिफरेंस कर सकता हूं और अगर मैं ऐसा करता हूं तो मुझे एक पूर्णांक मिलेगा 
 उस स्मृति स्थान पर। 
 >> ठीक है तो मैंने कहा कि सितारों के साथ एक और कष्टप्रद बात थी 
 और यहाँ सितारों के साथ उस कष्टप्रद बात है। 
 क्या आपने कभी एक ही प्रकार के कई चर घोषित करने की कोशिश की है 
 कोड की एक ही पंक्ति पर? 
 तो एक सेकंड के लिए, यह दिखावा करें कि लाइन, कोड जो वास्तव में मेरे पास हरे रंग में है 
 वहाँ नहीं है और यह सिर्फ int x, y, z; कहता है; 
 वास्तव में आपके लिए तीन पूर्णांक चर बनाए जाएंगे, 
 एक x कहलाता है, एक y कहलाता है, और एक z कहलाता है। 
 यह तीन लाइनों पर विभाजित किए बिना इसे करने का एक तरीका है। 
 >> यहाँ है जहाँ सितारों फिर से परेशान हो, 
 क्योंकि * वास्तव में नाम और भाग दोनों का हिस्सा है 
 चर नाम का। 
 और इसलिए अगर मैं कहता हूं कि int * px, py, pz, जो मुझे वास्तव में मिलता है वह एक पूर्णांक के लिए एक संकेतक है 

English: 
and if I do so, if I go to that address, what will I find at that address?
I will find an integer.
So int*p is basically saying, p is an address.
I can dereference p and if I do, I will find an integer
at that memory location.
>> OK so I said there was another annoying thing with stars
and here's where that annoying thing with stars is.
Have you ever tried to declare multiple variables of the same type
on the same line of code?
So for a second, pretend that the line, the code I actually have there in green
isn't there and it just says int x,y,z;.
What that would do is actually create three integer variables for you,
one called x, one called y, and one called z.
It's a way to do it without having to split onto three lines.
>> Here's where stars get annoying again though,
because the * is actually part of both the type name and part
of the variable name.
And so if I say int *px,py,pz, what I actually get is a pointer to an integer

Chinese: 
如果我這樣做的話，如果我去那個地址，我會在那個地址找到什麼？ 
我會找到一個整數。 
所以int * p基本上是說，p是一個地址。 
我可以解除對p的引用，如果這樣做，我會找到一個整數
在那個內存位置。 
 >>好，所以我說星星還有另外一件煩人的事
這就是星星的煩人之處。 
您是否曾經嘗試過聲明相同類型的多個變量
在同一行代碼上？ 
所以有一秒鐘，我假裝這行代碼，實際上我的代碼是綠色的
不存在，它只是說int x，y，z;。 
實際要做的就是為您創建三個整數變量， 
一個叫x，一個叫y，另一個叫z。 
這是一種無需拆分為三行的方法。 
 >>但是這裡的星星又變得令人討厭， 
因為*實際上是類型名稱和類型的一部分
變量名稱。 
所以如果我說int * px，py，pz，我實際上得到的是一個指向整數的指針

Portuguese: 
 e se eu fizer isso, se for para esse endereço, o que vou encontrar nesse endereço? 
 Vou encontrar um número inteiro. 
 Então int * p está basicamente dizendo, p é um endereço. 
 Eu posso desreferenciar pe, se o fizer, encontrarei um número inteiro 
 nesse local de memória. 
 >> OK, então eu disse que havia outra coisa chata com estrelas 
 e aqui é onde está aquela coisa chata com estrelas. 
 Você já tentou declarar várias variáveis ​​do mesmo tipo 
 na mesma linha de código? 
 Então, por um segundo, finja que a linha, o código que eu tenho lá em verde 
 não existe e diz apenas int x, y, z ;. 
 O que isso faria é criar três variáveis ​​inteiras para você, 
 um chamado x, um chamado y e um chamado z. 
 É uma maneira de fazer isso sem ter que dividir em três linhas. 
 >> Aqui é onde as estrelas se tornam irritantes novamente, 
 porque o * é realmente parte do nome do tipo e da parte 
 do nome da variável. 
 Então, se eu disser int * px, py, pz, o que realmente recebo é um ponteiro para um número inteiro 

Chinese: 
如果我这样做的话，如果我去那个地址，我会在那个地址找到什么？ 
我会找到一个整数。 
所以int * p基本上是说，p是一个地址。 
我可以解除对p的引用，如果这样做，我会找到一个整数
在那个内存位置。 
 >>好，所以我说星星还有另外一件烦人的事
这就是星星的烦人之处。 
您是否曾经尝试过声明相同类型的多个变量
在同一行代码上？ 
所以有一秒钟，我假装这行代码，实际上我的代码是绿色的
不存在，它只是说int x，y，z;。 
实际要做的就是为您创建三个整数变量， 
一个叫x，一个叫y，另一个叫z。 
这是一种无需拆分为三行的方法。 
 >>但是这里的星星又变得令人讨厌， 
因为*实际上是类型名称和类型的一部分
变量名称。 
所以如果我说int * px，py，pz，我实际上得到的是一个指向整数的指针

Russian: 
 и если я сделаю это, если я пойду по этому адресу, что я найду по этому адресу? 
 Я найду целое число. 
 Таким образом, int * p в основном говорит, p это адрес. 
 Я могу разыменовать р и если я сделаю, я найду целое число 
 в этом месте памяти. 
 >> Хорошо, так что я сказал, что была другая раздражающая вещь со звездами 
 и вот где эта раздражающая вещь со звездами. 
 Вы когда-нибудь пытались объявить несколько переменных одного типа 
 на той же строке кода? 
 Итак, на секунду представьте, что строка, код, который у меня есть, выделена зеленым 
 не там, и он просто говорит Int X, Y, Z ;. 
 Что бы это сделать, на самом деле создать три целочисленных переменных для вас, 
 один называется х, один называется у, а другой называется z. 
 Это способ сделать это без разделения на три строки. 
 >> Здесь звезды снова раздражают, хотя, 
 потому что * на самом деле является частью как имени типа, так и части 
 имени переменной. 
 И поэтому, если я скажу int * px, py, pz, я получу указатель на целое число 

Italian: 
 e se lo faccio, se vado a quell'indirizzo, cosa troverò a quell'indirizzo? 
 Troverò un numero intero. 
 Quindi int * p sta sostanzialmente dicendo, p è un indirizzo. 
 Posso dereference p e se lo faccio, troverò un numero intero 
 in quella posizione di memoria. 
 >> OK, quindi ho detto che c'era un'altra cosa fastidiosa con le stelle 
 ed ecco dove si trova quella cosa fastidiosa con le stelle. 
 Hai mai provato a dichiarare più variabili dello stesso tipo 
 sulla stessa riga di codice? 
 Quindi, per un secondo, fingi che la linea, il codice che ho effettivamente lì in verde 
 non c'è e dice solo int x, y, z ;. 
 Quello che farebbe in realtà è creare tre variabili intere per te, 
 uno chiamato x, uno chiamato y e uno chiamato z. 
 È un modo per farlo senza dover dividere su tre linee. 
 >> Ecco dove le stelle diventano di nuovo fastidiose però, 
 perché * è effettivamente parte sia del nome del tipo che della parte 
 del nome della variabile. 
 E quindi se dico int * px, py, pz, quello che ottengo effettivamente è un puntatore a un numero intero 

Indonesian: 
 dan jika saya melakukannya, jika saya pergi ke alamat itu, apa yang akan saya temukan di alamat itu? 
 Saya akan menemukan integer. 
 Jadi int * p pada dasarnya mengatakan, p adalah alamat. 
 Saya bisa dereference p dan jika saya lakukan, saya akan menemukan integer 
 di lokasi memori itu. 
 >> OK jadi saya katakan ada hal lain yang mengganggu dengan bintang 
 dan di sinilah hal yang menjengkelkan dengan bintang itu. 
 Pernahkah Anda mencoba mendeklarasikan beberapa variabel dari jenis yang sama 
 pada baris kode yang sama? 
 Jadi untuk sesaat, berpura-pura bahwa baris, kode saya benar-benar ada berwarna hijau 
 tidak ada di sana dan hanya mengatakan int x, y, z ;. 
 Apa yang akan dilakukan sebenarnya membuat tiga variabel integer untuk Anda, 
 satu disebut x, satu disebut y, dan satu disebut z. 
 Ini cara untuk melakukannya tanpa harus dibagi menjadi tiga baris. 
 >> Di sinilah bintang-bintang menjengkelkan lagi, 
 karena * sebenarnya bagian dari nama jenis dan bagian 
 nama variabel. 
 Jadi jika saya mengatakan int * px, py, pz, apa yang sebenarnya saya dapatkan adalah pointer ke integer 

Dutch: 
 en als ik dat doe, als ik naar dat adres ga, wat zal ik dan op dat adres vinden? 
 Ik zal een geheel getal vinden. 
 Dus int * p zegt in feite, p is een adres. 
 Ik kan p herleiden en als ik dat doe, zal ik een geheel getal vinden 
 op die geheugenlocatie. 
 >> OK, dus ik zei dat er nog iets vervelends was met sterren 
 en hier is dat vervelende ding met sterren. 
 Heb je ooit geprobeerd meerdere variabelen van hetzelfde type te declareren 
 op dezelfde regel code? 
 Dus doe even alsof de regel, de code die ik daar eigenlijk in het groen heb 
 is er niet en er staat alleen int x, y, z ;. 
 Wat dat zou doen, is eigenlijk drie integer-variabelen voor je maken, 
 één heet x, één heet y en één heet z. 
 Het is een manier om het te doen zonder op drie regels te hoeven splitsen. 
 >> Hier worden sterren echter weer irritant, 
 omdat de * eigenlijk deel uitmaakt van zowel de typenaam als het onderdeel 
 van de variabelenaam. 
 En dus als ik int * px, py, pz zeg, krijg ik eigenlijk een aanwijzer naar een geheel getal 

French: 
 et si je le fais, si je vais à cette adresse, que vais-je trouver à cette adresse? 
 Je vais trouver un entier. 
 Donc, int * p signifie essentiellement que p est une adresse. 
 Je peux déréférencer p et si je le fais, je trouverai un entier 
 à cet emplacement de mémoire. 
 >> OK alors j'ai dit qu'il y avait une autre chose ennuyeuse avec les étoiles 
 et voici où se trouve cette chose ennuyeuse avec les étoiles. 
 Avez-vous déjà essayé de déclarer plusieurs variables du même type 
 sur la même ligne de code? 
 Donc, pendant une seconde, faites comme si la ligne, le code que j'avais en fait en vert 
 n'est pas là et il dit simplement int x, y, z ;. 
 Ce que cela ferait est en fait de créer trois variables entières pour vous, 
 un appelé x, un appelé y et un appelé z. 
 C'est une façon de le faire sans avoir à diviser sur trois lignes. 
 >> Voici où les étoiles deviennent à nouveau ennuyeuses, 
 parce que le * fait en fait partie à la fois du nom du type et de la partie 
 du nom de la variable. 
 Et donc si je dis int * px, py, pz, ce que j'obtiens est un pointeur sur un entier 

Arabic: 
 وإذا قمت بذلك ، إذا ذهبت إلى هذا العنوان ، فماذا أجد في هذا العنوان؟ 
 سأجد عددًا صحيحًا. 
 إذاً int * p تقول بشكل أساسي ، p عنوان. 
 أستطيع أن ألغي الإشارة ، وإذا فعلت ذلك ، فسأجد عددًا صحيحًا 
 في موقع الذاكرة. 
 >> حسنًا ، قلت أن هناك شيئًا مزعجًا آخر مع النجوم 
 وهنا يكون ذلك الشيء المزعج مع النجوم. 
 هل سبق لك أن حاولت إعلان متغيرات متعددة من نفس النوع 
 على نفس السطر من التعليمات البرمجية؟ 
 لذا لثانية ، تظاهر بأن السطر ، الرمز الذي لدي بالفعل باللون الأخضر 
 غير موجود وتقول فقط int x، y، z ؛. 
 ما سيفعله ذلك في الواقع هو إنشاء ثلاثة متغيرات صحيحة لك ، 
 واحد يسمى س ، وآخر يسمى ص ، والآخر يسمى ض. 
 إنها طريقة للقيام بذلك دون الحاجة إلى الانقسام إلى ثلاثة خطوط. 
 >> هنا حيث تصبح النجوم مزعجة مرة أخرى ، 
 لأن * جزء فعلي من كل من اسم النوع والجزء 
 لاسم المتغير. 
 وهكذا إذا قلت int * px ، py ، pz ، ما أحصل عليه بالفعل هو مؤشر إلى عدد صحيح 

German: 
 und wenn ich das tue, wenn ich zu dieser Adresse gehe, was werde ich an dieser Adresse finden? 
 Ich werde eine ganze Zahl finden. 
 Int * p sagt also im Grunde, p ist eine Adresse. 
 Ich kann p dereferenzieren und wenn ich das tue, werde ich eine ganze Zahl finden 
 an diesem Speicherort. 
 >> OK, also sagte ich, dass es noch eine andere nervige Sache mit Sternen gibt 
 und hier ist das nervige Ding mit den Sternen. 
 Haben Sie jemals versucht, mehrere Variablen desselben Typs zu deklarieren? 
 in der gleichen Codezeile? 
 Stellen Sie sich für eine Sekunde vor, dass die Zeile, der Code, den ich dort tatsächlich habe, grün ist 
 ist nicht da und es heißt nur int x, y, z;. 
 Das würde tatsächlich drei ganzzahlige Variablen für Sie erstellen. 
 einer heißt x, einer heißt y und einer heißt z. 
 Dies ist eine Möglichkeit, ohne sich in drei Zeilen aufteilen zu müssen. 
 >> Hier werden die Sterne allerdings wieder nervig, 
 weil das * tatsächlich Teil sowohl des Typnamens als auch des Teils ist 
 des Variablennamens. 
 Wenn ich also int * px, py, pz sage, bekomme ich tatsächlich einen Zeiger auf eine ganze Zahl 

Modern Greek (1453-): 
 και αν το κάνω, αν πάω σε αυτή τη διεύθυνση, τι θα βρω σε αυτή τη διεύθυνση; 
 Θα βρω έναν ακέραιο αριθμό. 
 Έτσι int * p ουσιαστικά λέει, p είναι μια διεύθυνση. 
 Μπορώ να dereference p και αν το κάνω, θα βρω έναν ακέραιο αριθμό 
 σε εκείνη τη θέση μνήμης. 
 >> ΟΚ, έτσι είπα ότι υπήρχε ένα άλλο ενοχλητικό πράγμα με αστέρια 
 και εδώ είναι εκείνο το ενοχλητικό πράγμα με τα αστέρια. 
 Έχετε προσπαθήσει ποτέ να δηλώσετε πολλές μεταβλητές του ίδιου τύπου 
 στην ίδια γραμμή κώδικα; 
 Έτσι για ένα δευτερόλεπτο, προσποιούμαστε ότι η γραμμή, ο κώδικας που πραγματικά έχω εκεί σε πράσινο 
 δεν είναι εκεί και λέει μόνο int x, y, z ;. 
 Αυτό που θα έκανε είναι να δημιουργήσετε τρεις μεταβλητές ακέραιου αριθμού για εσάς, 
 ένας ονομάζεται x, ένας ονομάζεται y, και ένας ονομάζεται z. 
 Είναι ένας τρόπος να το κάνετε χωρίς να χρειάζεται να χωρίσετε σε τρεις γραμμές. 
 >> Εδώ είναι όπου τα αστέρια παίρνουν ενοχλητικά και πάλι όμως, 
 επειδή το * είναι στην πραγματικότητα μέρος τόσο του ονόματος τύπου όσο και του μέρους 
 του ονόματος της μεταβλητής. 
 Έτσι, αν λέω int * px, py, pz, αυτό που παίρνω είναι ένας δείκτης σε έναν ακέραιο αριθμό 

Chinese: 
称为px和两个整数py和pz。 
那可能不是我们想要的，那不是很好。 
 >>因此，如果我想在同一行的同一类型上创建多个指针， 
和星星，我实际上需要做的是说int * pa，* pb，* pc。 
现在刚刚说了这一点，现在告诉你， 
您可能永远不会这样做。 
说实话，这可能是一件好事，因为您可能会无意间
省略星星。 
最好在单独的行上声明指针， 
但这只是那些令人讨厌的语法中的另一种
有星星的东西使指针很难使用。 
因为这就是您必须解决的语法混乱。 
通过实践，它确实成为了第二天性。 
经过十年编程，我仍然会犯错误， 
因此，如果您发生任何事情，请不要生气，这是很常见的。 
这确实是语法的缺陷。 
 >>好的，所以我答应过我们
字符串有多大的概念。 

Dutch: 
 genaamd px en twee gehele getallen, py en pz. 
 En dat is waarschijnlijk niet wat we willen, dat is niet goed. 
 >> Dus als ik meerdere verwijzingen op dezelfde regel wil maken, van hetzelfde type, 
 en sterren, wat ik eigenlijk moet doen is int * pa, * pb, * pc zeggen. 
 Nu ik dat net heb gezegd en je dit nu vertel, 
 u zult dit waarschijnlijk nooit doen. 
 En het is waarschijnlijk een goede zaak, eerlijk gezegd, omdat je het per ongeluk zou kunnen doen 
 laat een ster weg, zoiets. 
 Het is waarschijnlijk het beste om pointers op individuele regels te declareren, 
 maar het is gewoon weer zo'n vervelende syntaxis 
 dingen met sterren die aanwijzers zo moeilijk maken om mee te werken. 
 Omdat het gewoon deze syntactische puinhoop is waar je doorheen moet werken. 
 Met oefenen wordt het echt een tweede natuur. 
 Ik maak er nog steeds fouten mee na 10 jaar programmeren, 
 dus wees niet boos als er iets met je gebeurt, het komt eerlijk gezegd vrij vaak voor. 
 Het is echt een minpunt van de syntaxis. 
 >> OK, dus ik heb een beetje beloofd dat we terug zouden komen 
 het concept van hoe groot een string is. 

Turkish: 
 px ve iki tamsayı olarak adlandırılır, py ve pz. 
 Muhtemelen istediğimiz bu değil, bu iyi değil. 
 >> Aynı satırda, aynı türde birden çok işaretçi oluşturmak istersem, 
 ve yıldızlar, aslında yapmam gereken şey int * pa, * pb, * pc demek. 
 Şimdi bunu söyledikten ve şimdi size bunu söyledikten sonra, 
 muhtemelen bunu asla yapmayacaksın. 
 Ve muhtemelen dürüst olmak gerekirse iyi bir şey, çünkü yanlışlıkla 
 bir yıldızı atlayın, böyle bir şey. 
 Muhtemelen tek tek satırlarda işaretçiler beyan etmek en iyisidir, 
 ama bu sinir bozucu sözdiziminden sadece bir diğeri 
 işaretçilerle çalışmayı zorlaştıran yıldızlara sahip şeyler. 
 Çünkü üzerinde çalışmanız gereken sözdizimsel karışıklık bu. 
 Uygulama ile gerçekten ikinci doğa haline gelir. 
 10 yıl boyunca programlamadan sonra hala hata yapıyorum, 
 bu yüzden size bir şey olursa üzülmeyin, dürüst olmak gerekirse oldukça yaygındır. 
 Bu sözdiziminin bir tür kusuru. 
 >> Tamam, bu yüzden tekrar ziyaret edeceğimize söz verdim 
 bir ipin ne kadar büyük olduğu kavramı. 

Spanish: 
 llamado px y dos enteros, py y pz. 
 Y eso probablemente no sea lo que queremos, eso no es bueno. 
 >> Entonces, si quiero crear múltiples punteros en la misma línea, del mismo tipo, 
 y estrellas, lo que realmente necesito hacer es decir int * pa, * pb, * pc. 
 Ahora que acabo de decir eso y ahora te digo esto, 
 probablemente nunca harás esto. 
 Y probablemente sea algo bueno, honestamente, porque puede que sin darse cuenta 
 omita una estrella, algo así. 
 Probablemente sea mejor declarar punteros en líneas individuales, 
 pero es solo otra de esas molestas sintaxis 
 cosas con estrellas que hacen que los punteros sean tan difíciles de trabajar. 
 Porque es solo este desastre sintáctico por el que tienes que trabajar. 
 Con la práctica, realmente se convierte en una segunda naturaleza. 
 Todavía cometo errores después de programar durante 10 años, 
 así que no te enojes si algo te sucede, es bastante común, sinceramente. 
 Es realmente un defecto de la sintaxis. 
 >> OK, así que prometí que volveríamos a visitar 
 El concepto de cuán grande es una cuerda. 

Modern Greek (1453-): 
 που ονομάζεται px και δύο ακέραιοι, py και pz. 
 Και αυτό πιθανώς δεν είναι αυτό που θέλουμε, αυτό δεν είναι καλό. 
 >> Έτσι, αν θέλω να δημιουργήσω πολλαπλούς δείκτες στην ίδια γραμμή, του ίδιου τύπου, 
 και αστέρια, αυτό που πραγματικά χρειάζεται να κάνω είναι να πω int * pa, * pb, * pc. 
 Τώρα μόλις το είπατε και τώρα σας λέω αυτό, 
 πιθανώς δεν θα το κάνετε ποτέ αυτό. 
 Και είναι ίσως καλό πράγμα ειλικρινά, γιατί ίσως ακούσια 
 παραλείψτε ένα αστέρι, κάτι τέτοιο. 
 Ίσως είναι καλύτερα να δηλώσετε δείκτες σε μεμονωμένες γραμμές, 
 αλλά είναι μόνο ένα από αυτά τα ενοχλητικά σύνταξη 
 πράγματα με αστέρια που κάνουν τους δείκτες τόσο δύσκολο να δουλέψουν. 
 Επειδή είναι ακριβώς αυτό το συντακτικό χάος που πρέπει να εργαστείτε. 
 Με την πρακτική αυτή πραγματικά γίνεται δεύτερη φύση. 
 Εξακολουθώ να κάνω λάθη με αυτό ακόμα μετά τον προγραμματισμό για 10 χρόνια, 
 οπότε μην ανησυχείτε αν σας συμβεί κάτι, είναι αρκετά κοινό ειλικρινά. 
 Είναι πραγματικά ένα είδος λάθους της σύνταξης. 
 >> ΟΚ, έτσι υποσχέθηκα κάπως ότι θα επισκεφθούμε ξανά 
 η έννοια του πόσο μεγάλη είναι μια συμβολοσειρά. 

Korean: 
 px와 두 개의 정수, py와 pz라고합니다. 
 그리고 그것은 아마도 우리가 원하는 것이 아닐 수도 있습니다. 
 >> 같은 줄에 같은 유형의 여러 포인터를 만들려면 
 그리고 별, 실제로 내가해야 할 일은 int * pa, * pb, * pc입니다. 
 이제 방금 말씀 드렸고 지금 여러분에게 
 당신은 아마 이것을하지 않을 것입니다. 
 우연히도 정직한 일 이겠지 
 별표를 생략하세요. 
 개별 행에 포인터를 선언하는 것이 가장 좋습니다. 
 하지만 그것은 성가신 구문 중 하나 일뿐입니다. 
 포인터를 다루기가 너무 어려운 별이있는 것들. 
 그것은 단지이 구문 엉망이기 때문에 작업해야합니다. 
 실제로는 제 2의 본성이됩니다. 
 10 년 동안 프로그래밍 한 후에도 여전히 실수를 저지 릅니다. 
 어떤 일이 생겨도 화 내지 마십시오. 정직합니다. 
 그것은 실제로 구문의 결함입니다. 
 >> 그래 우리가 다시 방문하겠다고 약속 했어 
 문자열의 크기 개념. 

French: 
 appelé px et deux entiers, py et pz. 
 Et ce n'est probablement pas ce que nous voulons, ce n'est pas bon. 
 >> Donc, si je veux créer plusieurs pointeurs sur la même ligne, du même type, 
 et les étoiles, ce que je dois réellement faire est de dire int * pa, * pb, * pc. 
 Maintenant que je viens de dire cela et que je vous le dis maintenant, 
 vous ne ferez probablement jamais cela. 
 Et c'est probablement une bonne chose honnêtement, car vous pourriez par inadvertance 
 omettre une étoile, quelque chose comme ça. 
 Il est probablement préférable de déclarer des pointeurs sur des lignes individuelles, 
 mais c'est juste une autre de ces syntaxe ennuyeuse 
 des choses avec des étoiles qui rendent les pointeurs si difficiles à travailler. 
 Parce que c'est juste ce désordre syntaxique que vous devez résoudre. 
 Avec la pratique, cela devient vraiment une seconde nature. 
 Je fais encore des erreurs avec après 10 ans de programmation, 
 alors ne vous inquiétez pas si quelque chose vous arrive, c'est assez commun honnêtement. 
 C'est vraiment une sorte de faille dans la syntaxe. 
 >> OK, j'ai donc promis de revoir 
 le concept de la taille d'une chaîne. 

Russian: 
 называется px и два целых числа, py и pz. 
 И это, вероятно, не то, что мы хотим, это не хорошо. 
 >> Так что, если я хочу создать несколько указателей на одной строке, одного типа, 
 и звезды, что мне действительно нужно, это сказать int * pa, * pb, * pc. 
 Теперь, только что сказав это, и теперь говорю вам это, 
 Вы, вероятно, никогда не будете делать это. 
 И, честно говоря, это хорошая вещь, потому что вы можете непреднамеренно 
 пропустить звезду, что-то в этом роде. 
 Возможно, лучше объявить указатели в отдельных строках, 
 но это просто еще один из тех раздражающих синтаксиса 
 вещи со звездами, с которыми так трудно работать с указателями. 
 Потому что это просто синтаксический беспорядок, через который ты должен пройти. 
 С практикой это действительно становится второй натурой. 
 Я все еще допускаю ошибки с этим после программирования в течение 10 лет, 
 так что не расстраивайтесь, если с вами что-то случится, честно говоря, это довольно часто. 
 Это действительно своего рода недостаток синтаксиса. 
 >> Хорошо, так что я вроде обещал, что мы вернемся 
 понятие о том, насколько велика строка. 

Japanese: 
 pxと2つの整数pyおよびpzと呼ばれます。 
そしてそれはおそらく私たちが望むものではありません、それは良くありません。 
 >>つまり、同じ行に同じタイプの複数のポインタを作成したい場合は、 
と星、私が実際に行う必要があるのは、int * pa、* pb、* pcと言うことです。 
今それを言って今あなたにこれを言って、 
あなたはおそらくこれを行うことはありません。 
そして、それは正直に言っておそらく良いことです。 
星は省略します。 
おそらく、個々の行でポインターを宣言するのが最善でしょう。 
しかし、それはそれらの迷惑な構文のもう1つにすぎません
ポインターを操作するのが非常に困難になる星のあるもの。 
それは、この構文上の混乱であり、対処する必要があるからです。 
練習によってそれは本当に第二の性質になります。 
まだ10年間プログラミングした後も、まだ間違いを犯しています。 
何かが起こっても動揺しないでください、それは正直なところかなり一般的です。 
それは本当に構文の欠陥のようなものです。 
 >>わかりましたので、再訪すると約束しました
文字列の大きさの概念。 

Hindi: 
 px और दो पूर्णांक, py और pz कहलाते हैं। 
 और शायद यही हम नहीं चाहते हैं, यह अच्छा नहीं है। 
 >> तो अगर मैं एक ही प्रकार के एक ही लाइन पर कई पॉइंटर्स बनाना चाहता हूं, 
 और सितारों, जो मुझे वास्तव में करने की ज़रूरत है, वह कहते हैं int * pa, * pb, * pc। 
 अब बस इतना कहा है और अब आपको यह बता, 
 आप शायद ऐसा कभी नहीं करेंगे। 
 और यह शायद ईमानदारी से एक अच्छी बात है, क्योंकि आप अनजाने में हो सकते हैं 
 एक स्टार को छोड़ दें, ऐसा कुछ। 
 व्यक्तिगत रेखाओं पर पॉइंटर्स घोषित करना शायद सबसे अच्छा है, 
 लेकिन यह सिर्फ उन कष्टप्रद वाक्यविन्यास में से एक है 
 सितारों के साथ चीजें जो पॉइंटर्स को काम करना मुश्किल बनाती हैं। 
 क्योंकि यह सिर्फ इस सिंथैटिक गड़बड़ है जिसके माध्यम से आपको काम करना है। 
 अभ्यास के साथ यह वास्तव में दूसरी प्रकृति बन जाता है। 
 मैं 10 साल तक प्रोग्रामिंग करने के बाद भी इसके साथ गलतियाँ करता हूँ, 
 इसलिए परेशान मत होइए अगर आपके साथ कुछ होता है, तो यह बहुत सामान्य रूप से ईमानदारी से है। 
 यह वास्तव में वाक्य रचना के दोष की तरह है। 
 >> ठीक है तो मैंने वादा किया था कि हम फिर से विचार करेंगे 
 एक स्ट्रिंग कितनी बड़ी है, इसकी अवधारणा। 

Arabic: 
 دعا px واثنين من الأعداد الصحيحة ، py و pz. 
 وربما هذا ليس ما نريده ، هذا ليس جيدًا. 
 >> لذا إذا كنت أرغب في إنشاء مؤشرات متعددة على نفس السطر من نفس النوع ، 
 والنجوم ، ما أحتاج فعله هو قول int * pa ، * pb ، * pc. 
 الآن وقد قلت ذلك للتو وأخبرك بذلك الآن ، 
 ربما لن تفعل هذا أبداً. 
 وربما يكون هذا أمرًا جيدًا بصدق ، لأنك قد تكون عن غير قصد 
 احذف نجمة ، شيء من هذا القبيل. 
 ربما من الأفضل الإعلان عن المؤشرات على الخطوط الفردية ، 
 لكنها مجرد واحدة أخرى من تلك الصيغة المزعجة 
 أشياء بالنجوم تجعل من الصعب التعامل مع المؤشرات. 
 لأنه فقط هذه الفوضى النحوية عليك العمل من خلالها. 
 مع الممارسة تصبح حقا الطبيعة الثانية. 
 ما زلت أرتكبها بعد البرمجة لمدة 10 سنوات ، 
 لذلك لا تنزعج إذا حدث شيء ما ، فهذا أمر شائع جدًا بصدق. 
 إنه نوع من خلل في بناء الجملة. 
 >> حسنًا ، لقد وعدت نوعًا ما بأننا سنعيد النظر 
 مفهوم حجم السلسلة. 

Chinese: 
稱為px和兩個整數py和pz。 
那可能不是我們想要的，那不是很好。 
 >>因此，如果我想在同一行的同一類型上創建多個指針， 
和星星，我實際上需要做的是說int * pa，* pb，* pc。 
現在剛剛說了這一點，現在告訴你， 
您可能永遠不會這樣做。 
說實話，這可能是一件好事，因為您可能會無意間
省略星星。 
最好在單獨的行上聲明指針， 
但這只是那些令人討厭的語法中的另一種
有星星的東西使指針很難使用。 
因為這就是您必須解決的語法混亂。 
通過實踐，它確實成為了第二天性。 
經過十年編程，我仍然會犯錯誤， 
因此，如果您發生任何事情，請不要生氣，這是很常見的。 
這確實是語法的缺陷。 
 >>好的，所以我答應過我們
字符串有多大的概念。 

Portuguese: 
 chamado px e dois números inteiros, py e pz. 
 E provavelmente não é isso que queremos, isso não é bom. 
 >> Então, se eu quiser criar vários ponteiros na mesma linha, do mesmo tipo, 
 e estrelas, o que eu realmente preciso fazer é dizer int * pa, * pb, * pc. 
 Agora, tendo acabado de dizer isso e agora dizendo isso, 
 você provavelmente nunca fará isso. 
 E provavelmente é uma coisa boa, honestamente, porque você pode inadvertidamente 
 omitir uma estrela, algo assim. 
 Provavelmente, é melhor talvez declarar ponteiros em linhas individuais, 
 mas é apenas mais uma daquelas sintaxe irritante 
 coisas com estrelas que tornam os ponteiros tão difíceis de trabalhar. 
 Porque é apenas essa bagunça sintática que você precisa resolver. 
 Com a prática, ela realmente se torna uma segunda natureza. 
 Eu ainda cometo erros depois de programar por 10 anos, 
 portanto, não fique chateado se algo acontecer com você, é bem comum, honestamente. 
 É realmente uma espécie de falha da sintaxe. 
 >> OK, então eu meio que prometi que revisitaríamos 
 o conceito de quão grande é uma string. 

Italian: 
 chiamato px e due numeri interi, py e pz. 
 E probabilmente non è quello che vogliamo, non va bene. 
 >> Quindi, se voglio creare più puntatori sulla stessa riga, dello stesso tipo, 
 e le stelle, ciò che effettivamente devo fare è dire int * pa, * pb, * pc. 
 Ora avendo appena detto questo e ora dirti questo, 
 probabilmente non lo farai mai. 
 Ed è probabilmente una buona cosa onestamente, perché potresti inavvertitamente 
 ometti una stella, qualcosa del genere. 
 Probabilmente è meglio dichiarare i puntatori su singole righe, 
 ma è solo un'altra di quelle fastidiose sintassi 
 cose con stelle che rendono i puntatori così difficili da lavorare. 
 Perché è solo questo pasticcio sintattico che devi affrontare. 
 Con la pratica diventa davvero una seconda natura. 
 Continuo a commettere errori ancora dopo aver programmato per 10 anni, 
 quindi non arrabbiarti se ti succede qualcosa, è abbastanza comune onestamente. 
 È davvero un difetto della sintassi. 
 >> OK, quindi ho promesso che avremmo rivisitato 
 il concetto di quanto è grande una stringa. 

English: 
called px and two integers, py and pz.
And that's probably not what we want, that's not good.
>> So if I want to create multiple pointers on the same line, of the same type,
and stars, what I actually need to do is say int *pa,*pb,*pc.
Now having just said that and now telling you this,
you probably will never do this.
And it's probably a good thing honestly, because you might inadvertently
omit a star, something like that.
It's probably best to maybe declare pointers on individual lines,
but it's just another one of those annoying syntax
things with stars that make pointers so difficult to work with.
Because it's just this syntactic mess you have to work through.
With practice it does really become second nature.
I still make mistakes with it still after programming for 10 years,
so don't be upset if something happens to you, it's pretty common honestly.
It's really kind of a flaw of the syntax.
>> OK so I kind of promised that we would revisit
the concept of how large is a string.

Indonesian: 
 disebut px dan dua bilangan bulat, py dan pz. 
 Dan itu mungkin bukan yang kita inginkan, itu tidak baik. 
 >> Jadi jika saya ingin membuat banyak pointer pada baris yang sama, dari jenis yang sama, 
 dan bintang-bintang, apa yang sebenarnya perlu saya lakukan adalah mengatakan int * pa, * pb, * pc. 
 Sekarang baru saja mengatakan itu dan sekarang memberitahu Anda ini, 
 Anda mungkin tidak akan pernah melakukan ini. 
 Dan itu mungkin hal yang baik secara jujur, karena Anda mungkin secara tidak sengaja 
 menghilangkan bintang, sesuatu seperti itu. 
 Mungkin terbaik untuk mendeklarasikan pointer pada setiap baris, 
 tapi itu hanyalah salah satu dari sintaks yang menjengkelkan 
 hal-hal dengan bintang yang membuat pointer jadi sulit untuk dikerjakan. 
 Karena ini hanya kekacauan sintaksis yang harus Anda selesaikan. 
 Dengan latihan itu benar-benar menjadi sifat kedua. 
 Saya masih membuat kesalahan dengan itu masih setelah pemrograman selama 10 tahun, 
 jadi jangan kecewa jika sesuatu terjadi pada Anda, itu cukup umum jujur. 
 Ini benar-benar semacam cacat sintaksis. 
 >> OK jadi saya agak berjanji bahwa kami akan mengunjungi kembali 
 konsep seberapa besar string. 

German: 
 genannt px und zwei ganze Zahlen, py und pz. 
 Und das wollen wir wahrscheinlich nicht, das ist nicht gut. 
 >> Wenn ich also mehrere Zeiger in derselben Zeile desselben Typs erstellen möchte, 
 und Sterne, was ich eigentlich tun muss, ist int * pa, * pb, * pc zu sagen. 
 Nachdem ich das gerade gesagt habe und dir das jetzt erzähle, 
 Sie werden dies wahrscheinlich nie tun. 
 Und es ist wahrscheinlich eine gute Sache, ehrlich gesagt, weil Sie möglicherweise versehentlich 
 Lass einen Stern weg, so etwas. 
 Es ist wahrscheinlich am besten, Zeiger auf einzelnen Zeilen zu deklarieren. 
 aber es ist nur eine andere dieser nervigen Syntax 
 Dinge mit Sternen, die es so schwierig machen, mit Zeigern zu arbeiten. 
 Weil es nur dieses syntaktische Durcheinander ist, das Sie durcharbeiten müssen. 
 Mit der Übung wird es wirklich zur zweiten Natur. 
 Ich mache immer noch Fehler damit, nachdem ich 10 Jahre lang programmiert habe. 
 Sei also nicht verärgert, wenn dir etwas passiert, es ist ehrlich gesagt ziemlich üblich. 
 Es ist wirklich ein Fehler in der Syntax. 
 >> OK, also habe ich irgendwie versprochen, dass wir wiederkommen würden 
 das Konzept, wie groß eine Zeichenfolge ist. 

Indonesian: 
 Nah jika saya katakan itu string, kami benar-benar baik 
 berbohong padamu sepanjang waktu. 
 Tidak ada tipe data yang disebut string, dan sebenarnya saya 
 menyebutkan ini di salah satu video kami yang paling awal tentang tipe data, 
 string itu adalah tipe data yang dibuat untuk Anda di CS50.h. 
 Anda harus memasukkan # CS50.h untuk menggunakannya. 
 >> Yah string benar-benar hanya alias untuk sesuatu 
 disebut char *, sebuah penunjuk ke sebuah karakter. 
 Pointer yang baik, ingat, hanya alamat. 
 Jadi berapa ukuran dalam byte dari sebuah string? 
 Ya empat atau delapan. 
 Dan alasan saya mengatakan empat atau delapan adalah karena sebenarnya 
 tergantung pada sistem, Jika Anda menggunakan ide CS50, char * adalah ukuran char 
 * delapan, ini sistem 64-bit. 
 Setiap alamat dalam memori adalah 64 bit. 
 Jika Anda menggunakan alat CS50 atau menggunakan mesin 32-bit, 
 dan Anda pernah mendengar istilah mesin 32-bit, apa itu mesin 32-bit? 
 Yah itu hanya berarti bahwa setiap alamat dalam memori adalah 32 bit. 
 Jadi 32 bit adalah empat byte. 

Arabic: 
 حسنًا ، إذا أخبرتك أن هناك سلسلة ، فنحن بالفعل نوعًا ما 
 كان يكذب عليك طوال الوقت. 
 لا يوجد نوع بيانات يسمى سلسلة ، وفي الحقيقة أنا 
 ذكر هذا في أحد أقدم مقاطع الفيديو حول أنواع البيانات ، 
 كانت تلك السلسلة نوع بيانات تم إنشاؤه لك في CS50.h. 
 يجب عليك تضمين CS50.h حتى تتمكن من استخدامه. 
 >> السلسلة جيدة حقًا اسم مستعار لشيء ما 
 يسمى حرف * ، مؤشر إلى حرف. 
 أذكر أن المؤشرات الجيدة هي مجرد عناوين. 
 إذن ما هو حجم بايتات السلسلة؟ 
 حسنًا ، إنها أربعة أو ثمانية. 
 والسبب في أنني أقول أربعة أو ثمانية لأنه في الواقع 
 يعتمد على النظام ، إذا كنت تستخدم CS50 ide ، فإن char * هو حجم حرف 
 * ثمانية ، نظام 64 بت. 
 كل عنوان في الذاكرة بطول 64 بت. 
 إذا كنت تستخدم جهاز CS50 أو تستخدم أي جهاز 32 بت ، 
 وسمعت هذا المصطلح آلة 32 بت ، ما هو الجهاز 32 بت؟ 
 حسنًا ، هذا يعني فقط أن كل عنوان في الذاكرة بطول 32 بت. 
 وبالتالي فإن 32 بت هي أربعة بايت. 

French: 
 Eh bien, si je vous disais qu'une chaîne, nous avons vraiment une sorte de 
 vous a menti tout le temps. 
 Il n'y a pas de type de données appelé chaîne, et en fait je 
 mentionné dans l'une de nos premières vidéos sur les types de données, 
 cette chaîne était un type de données créé pour vous dans CS50.h. 
 Vous devez #inclure CS50.h pour l'utiliser. 
 >> Eh bien, la chaîne est vraiment juste un alias pour quelque chose 
 appelé le char *, un pointeur sur un personnage. 
 Les pointeurs, rappelez-vous, ne sont que des adresses. 
 Quelle est donc la taille en octets d'une chaîne? 
 Eh bien, c'est quatre ou huit. 
 Et la raison pour laquelle je dis quatre ou huit, c'est parce que 
 dépend du système, si vous utilisez CS50 ide, char * est la taille d'un char 
 * est huit, c'est un système 64 bits. 
 Chaque adresse en mémoire a une longueur de 64 bits. 
 Si vous utilisez l'appliance CS50 ou une machine 32 bits, 
 et vous avez entendu ce terme machine 32 bits, qu'est-ce qu'une machine 32 bits? 
 Eh bien, cela signifie simplement que chaque adresse en mémoire a une longueur de 32 bits. 
 Et donc 32 bits est de quatre octets. 

Russian: 
 Ну, если бы я сказал вам, что строка, мы действительно отчасти 
 лгал вам все время. 
 Там нет типа данных с именем строки, и на самом деле я 
 упомянул об этом в одном из наших первых видео о типах данных, 
 эта строка была типом данных, который был создан для вас в CS50.h. 
 Вы должны включить CS50.h, чтобы использовать его. 
 >> Ну строка действительно просто псевдоним для чего-то 
 называется char *, указатель на символ. 
 Ну указатели, напомним, это просто адреса. 
 Каков размер строки в байтах? 
 Ну, это четыре или восемь. 
 И причина, по которой я говорю, четыре или восемь, потому что это на самом деле 
 зависит от системы. Если вы используете CS50 ide, char * - это размер char 
 * это восемь, это 64-битная система. 
 Каждый адрес в памяти имеет длину 64 бита. 
 Если вы используете устройство CS50 или любой другой 32-битный компьютер, 
 и вы слышали этот термин 32-битный компьютер, что такое 32-битный компьютер? 
 Ну, это просто означает, что каждый адрес в памяти имеет длину 32 бита. 
 И так 32 бита - это четыре байта. 

Turkish: 
 Sana bir ip olduğunu söylersem, 
 bütün zaman sana yalan söylüyorum. 
 Dize adı verilen bir veri türü yoktur ve aslında ben 
 veri türleriyle ilgili en eski videolarımızdan birinde bunu belirtti, 
 bu dize, CS50.h dosyasında sizin için oluşturulan bir veri türüdür. 
 Kullanmak için # CS50.h eklemeniz gerekir. 
 >> Dize gerçekten bir şey için takma addır 
 karakter * olarak adlandırılan karakter * olarak adlandırılır. 
 İşaretçiler, hatırlayın, sadece adreslerdir. 
 Peki bir dizenin bayt cinsinden boyutu nedir? 
 Dört ya da sekiz. 
 Dört ya da sekiz dememin sebebi aslında 
 sisteme bağlıdır, CS50 ide kullanıyorsanız, char * bir char boyutudur 
 * sekiz, 64 bit sistem. 
 Bellekteki her adres 64 bit uzunluğundadır. 
 CS50 cihazı veya herhangi bir 32 bit makine kullanıyorsanız, 
 32-bit makine terimini duydunuz, 32-bit makine nedir? 
 Bu sadece bellekteki her adresin 32 bit uzunluğunda olduğu anlamına gelir. 
 Ve böylece 32 bit dört bayttır. 

Hindi: 
 वैसे अगर मैंने आपसे कहा है कि एक स्ट्रिंग, हम वास्तव में की तरह है 
 पूरे समय आपसे झूठ बोलता रहा। 
 कोई डेटा प्रकार नहीं है जिसे स्ट्रिंग कहा जाता है, और वास्तव में I 
 डेटा प्रकारों पर हमारे शुरुआती वीडियो में इसका उल्लेख किया गया है, 
 वह स्ट्रिंग एक डेटा प्रकार था जो आपके लिए CS50.h में बनाया गया था। 
 आपको इसका उपयोग करने के लिए CS50.h को #include करना होगा। 
 >> अच्छी तरह से स्ट्रिंग वास्तव में किसी चीज के लिए केवल एक उपनाम है 
 कहा जाता है चार *, एक चरित्र के लिए एक सूचक। 
 खैर संकेत, याद, सिर्फ पते हैं। 
 तो एक स्ट्रिंग के बाइट्स में आकार क्या है? 
 वैसे यह चार या आठ है। 
 और मैं चार या आठ कहने का कारण यह है क्योंकि यह वास्तव में है 
 सिस्टम पर निर्भर करता है, यदि आप CS50 विचारधारा का उपयोग कर रहे हैं, तो char * एक char का आकार है 
 * आठ है, यह 64-बिट सिस्टम है। 
 स्मृति में प्रत्येक पता 64 बिट लंबा है। 
 यदि आप CS50 उपकरण का उपयोग कर रहे हैं या किसी 32-बिट मशीन का उपयोग कर रहे हैं, 
 और आपने उस शब्द को 32-बिट मशीन के रूप में सुना है, 32-बिट मशीन क्या है? 
 वैसे इसका सिर्फ इतना मतलब है कि मेमोरी में हर पता 32 बिट लंबा है। 
 और इसलिए 32 बिट्स चार बाइट्स हैं। 

Japanese: 
文字列だと言ったら、 
ずっとあなたに嘘をついています。 
文字列と呼ばれるデータ型はありません、そして実際私は
データ型に関する最初のビデオでこれについて言及しました
その文字列は、CS50.hで作成されたデータ型です。 
これを使用するには、CS50.hを#includeする必要があります。 
 >>まあ文字列は本当に何かの単なるエイリアスです
 char *と呼ばれ、文字へのポインタです。 
まあポインタは、思い出してください、単にアドレスです。 
では、文字列のバイト単位のサイズは何ですか？ 
まあそれは4または8です。 
そして私が4または8と言う理由はそれが実際にあるからです
システムによって異なります。CS50ideを使用している場合、char *はcharのサイズです
 * 8です。これは64ビットシステムです。 
メモリ内のすべてのアドレスは64ビット長です。 
 CS50アプライアンスまたは32ビットマシンを使用している場合、 
 32ビットマシンという用語を聞いたことがありますが、32ビットマシンとは何ですか。 
メモリ内のすべてのアドレスが32ビット長であることを意味します。 
つまり、32ビットは4バイトです。 

Italian: 
 Bene, se ti dicessi che una stringa, abbiamo davvero 
 ti ho mentito tutto il tempo. 
 Non esiste un tipo di dati chiamato stringa, e in effetti io 
 menzionato questo in uno dei nostri primi video sui tipi di dati, 
 quella stringa era un tipo di dati creato per te in CS50.h. 
 Devi #includere CS50.h per usarlo. 
 >> Beh, la stringa è davvero solo un alias per qualcosa 
 chiamato char *, un puntatore a un personaggio. 
 Bene, i puntatori, ricordiamo, sono solo indirizzi. 
 Quindi qual è la dimensione in byte di una stringa? 
 Beh, sono le quattro o le otto. 
 E il motivo per cui dico quattro o otto è perché in realtà 
 dipende dal sistema, se stai usando CS50 ide, char * è la dimensione di un char 
 * è otto, è un sistema a 64 bit. 
 Ogni indirizzo in memoria è lungo 64 bit. 
 Se si utilizza l'appliance CS50 o si utilizza una macchina a 32 bit, 
 e hai sentito quel termine macchina a 32 bit, cos'è una macchina a 32 bit? 
 Bene significa solo che ogni indirizzo in memoria è lungo 32 bit. 
 E così 32 bit sono quattro byte. 

Chinese: 
好吧，如果我告訴你一個字符串，我們真的
一直在騙你
沒有稱為字符串的數據類型，實際上我
在我們最早的有關數據類型的視頻中提到了這一點， 
該字符串是在CS50.h中為您創建的數據類型。 
您必須#include CS50.h才能使用它。 
 >>字符串實際上只是某些東西的別名
稱為char *，它是指向字符的指針。 
指針，回想起來，僅僅是地址。 
那麼字符串的字節大小是多少？ 
好吧，現在是四八點。 
我說四或八個原因是因為它實際上
取決於系統，如果您使用的是CS50 ide，則char *是char的大小
 *是8，這是一個64位系統。 
內存中的每個地址均為64位長。 
如果您使用的是CS50設備或任何32位計算機， 
並且您聽說過術語32位計算機，什麼是32位計算機？ 
嗯，這只是意味著內存中的每個地址都是32位長。 
因此，32位是四個字節。 

German: 
 Nun, wenn ich dir sagen würde, dass es sich um eine Saite handelt, haben wir das wirklich 
 habe dich die ganze Zeit angelogen. 
 Es gibt keinen Datentyp namens string, und tatsächlich ich 
 erwähnte dies in einem unserer frühesten Videos zu Datentypen, 
 Diese Zeichenfolge war ein Datentyp, der in CS50.h für Sie erstellt wurde. 
 Sie müssen CS50.h # einschließen, um es zu verwenden. 
 >> Nun, String ist wirklich nur ein Alias ​​für etwas 
 genannt das char *, ein Zeiger auf ein Zeichen. 
 Nun, Zeiger sind nur Adressen. 
 Wie groß ist eine Zeichenfolge in Byte? 
 Nun, es ist vier oder acht. 
 Und der Grund, warum ich vier oder acht sage, ist, dass es tatsächlich so ist 
 hängt vom System ab. Wenn Sie CS50 ide verwenden, ist char * die Größe eines Zeichens 
 * ist acht, es ist ein 64-Bit-System. 
 Jede Adresse im Speicher ist 64 Bit lang. 
 Wenn Sie eine CS50-Appliance oder einen 32-Bit-Computer verwenden, 
 und Sie haben diesen Begriff 32-Bit-Maschine gehört, was ist eine 32-Bit-Maschine? 
 Nun, es bedeutet nur, dass jede Adresse im Speicher 32 Bit lang ist. 
 Und so sind 32 Bit vier Bytes. 

Dutch: 
 Als ik je dat een touwtje vertel, dan hebben we er eigenlijk een soort van 
 heb de hele tijd tegen je gelogen. 
 Er is geen gegevenstype genaamd string, en in feite ik 
 noemde dit in een van onze eerste video's over gegevenstypen, 
 die tekenreeks was een gegevenstype dat voor u is gemaakt in CS50.h. 
 Je moet CS50.h #include om het te gebruiken. 
 >> Nou string is eigenlijk gewoon een alias voor iets 
 riep de char *, een aanwijzer naar een personage. 
 Welnu, verwijzingen zijn slechts adressen. 
 Dus wat is de grootte in bytes van een string? 
 Nou, het is vier of acht. 
 En de reden dat ik vier of acht zeg, is omdat het eigenlijk zo is 
 hangt af van het systeem. Als je CS50 ide gebruikt, is char * de grootte van een char 
 * is acht, het is een 64-bits systeem. 
 Elk adres in het geheugen is 64 bits lang. 
 Als u een CS50-apparaat gebruikt of een 32-bits machine gebruikt, 
 en je hebt die term 32-bits machine gehoord, wat is een 32-bits machine? 
 Het betekent gewoon dat elk adres in het geheugen 32 bits lang is. 
 En dus is 32 bits vier bytes. 

Modern Greek (1453-): 
 Λοιπόν, αν σας είπα ότι μια χορδή, έχουμε πραγματικά ένα είδος 
 σας ψέμαζε όλη την ώρα. 
 Δεν υπάρχει τύπος δεδομένων που ονομάζεται συμβολοσειρά, και στην πραγματικότητα εγώ 
 ανέφερε αυτό σε ένα από τα πρώτα μας βίντεο σχετικά με τους τύπους δεδομένων, 
 αυτή η συμβολοσειρά ήταν ένας τύπος δεδομένων που δημιουργήθηκε για εσάς στο CS50.h. 
 Πρέπει να συμπεριλάβετε το CS50.h για να το χρησιμοποιήσετε. 
 >> Η συμβολοσειρά είναι πραγματικά ένα ψευδώνυμο για κάτι 
 που ονομάζεται char *, ένας δείκτης σε ένα χαρακτήρα. 
 Καλά δείκτες, θυμηθείτε, είναι μόνο διευθύνσεις. 
 Έτσι ποιο είναι το μέγεθος σε bytes μιας συμβολοσειράς; 
 Λοιπόν είναι τέσσερα ή οκτώ. 
 Και ο λόγος που λέω τέσσερα ή οχτώ είναι επειδή πραγματικά 
 εξαρτάται από το σύστημα. Εάν χρησιμοποιείτε το CS50 ide, το char * είναι το μέγεθος ενός char 
 * είναι οκτώ, είναι ένα σύστημα 64-bit. 
 Κάθε διεύθυνση στη μνήμη είναι 64 bit long. 
 Αν χρησιμοποιείτε συσκευή CS50 ή χρησιμοποιείτε οποιοδήποτε μηχάνημα 32 bit, 
 και έχετε ακούσει αυτό τον όρο μηχάνημα 32 bit, τι είναι μια μηχανή 32 bit; 
 Λοιπόν σημαίνει απλώς ότι κάθε διεύθυνση στη μνήμη έχει μήκος 32 bits. 
 Και έτσι 32 bit είναι τέσσερα byte. 

Chinese: 
好吧，如果我告诉你一个字符串，我们真的
一直在骗你
没有称为字符串的数据类型，实际上我
在我们最早的有关数据类型的视频中提到了这一点， 
该字符串是在CS50.h中为您创建的数据类型。 
您必须#include CS50.h才能使用它。 
 >>字符串实际上只是某些东西的别名
称为char *，它是指向字符的指针。 
指针，回想起来，仅仅是地址。 
那么字符串的字节大小是多少？ 
好吧，现在是四八点。 
我说四或八个原因是因为它实际上
取决于系统，如果您使用的是CS50 ide，则char *是char的大小
 *是8，这是一个64位系统。 
内存中的每个地址均为64位长。 
如果您使用的是CS50设备或任何32位计算机， 
并且您听说过术语32位计算机，什么是32位计算机？ 
嗯，这只是意味着内存中的每个地址都是32位长。 
因此，32位是四个字节。 

English: 
Well if I told you that a string, we've really kind of
been lying to you the whole time.
There's no data type called string, and in fact I
mentioned this in one of our earliest videos on data types,
that string was a data type that was created for you in CS50.h.
You have to #include CS50.h in order to use it.
>> Well string is really just an alias for something
called the char *, a pointer to a character.
Well pointers, recall, are just addresses.
So what is the size in bytes of a string?
Well it's four or eight.
And the reason I say four or eight is because it actually
depends on the system, If you're using CS50 ide, char * is the size of a char
* is eight, it's a 64-bit system.
Every address in memory is 64 bits long.
If you're using CS50 appliance or using any 32-bit machine,
and you've heard that term 32-bit machine, what is a 32-bit machine?
Well it just means that every address in memory is 32 bits long.
And so 32 bits is four bytes.

Portuguese: 
 Bem, se eu lhe disse que uma corda, nós realmente meio que 
 menti para você o tempo todo. 
 Não há tipo de dados chamado string, e na verdade eu 
 mencionou isso em um dos nossos primeiros vídeos sobre tipos de dados, 
 essa sequência era um tipo de dados criado para você no CS50.h. 
 Você precisa # incluir o CS50.h para usá-lo. 
 >> Bem, a string é realmente apenas um apelido para algo 
 chamado char *, um ponteiro para um personagem. 
 Lembre-se de que ponteiros são apenas endereços. 
 Então, qual é o tamanho em bytes de uma string? 
 Bem, são quatro ou oito. 
 E a razão pela qual digo quatro ou oito é porque na verdade 
 depende do sistema. Se você estiver usando o CS50 ide, char * é do tamanho de um char 
 * é oito, é um sistema de 64 bits. 
 Todo endereço na memória tem 64 bits. 
 Se você estiver usando o dispositivo CS50 ou qualquer máquina de 32 bits, 
 e você já ouviu esse termo máquina de 32 bits, o que é uma máquina de 32 bits? 
 Bem, isso apenas significa que todo endereço na memória tem 32 bits. 
 E então 32 bits são quatro bytes. 

Spanish: 
 Bueno, si te digo que es una cuerda, realmente tenemos 
 te he estado mintiendo todo el tiempo 
 No hay ningún tipo de datos llamado cadena, y de hecho yo 
 mencioné esto en uno de nuestros primeros videos sobre tipos de datos, 
 esa cadena era un tipo de datos que se creó para usted en CS50.h. 
 Tienes que #incluir CS50.h para usarlo. 
 >> Bueno, la cadena es realmente solo un alias para algo 
 llamado char *, un puntero a un personaje. 
 Los punteros, recuerda, son solo direcciones. 
 Entonces, ¿cuál es el tamaño en bytes de una cadena? 
 Bueno, son las cuatro u ocho. 
 Y la razón por la que digo cuatro u ocho es porque en realidad 
 depende del sistema, si está usando CS50 ide, char * es del tamaño de un char 
 * es ocho, es un sistema de 64 bits. 
 Cada dirección en la memoria tiene 64 bits de longitud. 
 Si está utilizando un dispositivo CS50 o cualquier máquina de 32 bits, 
 y has escuchado el término máquina de 32 bits, ¿qué es una máquina de 32 bits? 
 Bueno, solo significa que cada dirección en la memoria tiene 32 bits de longitud. 
 Y entonces 32 bits son cuatro bytes. 

Korean: 
 글쎄, 내가 줄을 말하면, 우리는 정말 
 항상 너에게 거짓말을 했어 
 string이라는 데이터 유형이 없으며 실제로는 
 데이터 유형에 대한 가장 빠른 비디오 중 하나에서 이것을 언급했습니다. 
 해당 문자열은 CS50.h에서 생성 된 데이터 형식입니다. 
 CS50.h를 사용하려면 #include해야합니다. 
 >> 글쎄, 문자열은 실제로 무언가의 별칭입니다. 
 문자 *를 가리키는 문자 *. 
 글쎄, 포인터는 주소 일뿐입니다. 
 문자열의 바이트 크기는 얼마입니까? 
 글쎄요, 4-8입니다. 
 제가 4-8이라고 말하는 이유는 실제로 
 CS50 IDE를 사용하는 경우 char *는 char의 크기입니다. 
 *는 8이며 64 비트 시스템입니다. 
 메모리의 모든 주소는 64 비트입니다. 
 CS50 어플라이언스를 사용하거나 32 비트 시스템을 사용하는 경우 
 32 비트 시스템이라는 용어를 들었습니다. 32 비트 시스템이란 무엇입니까? 
 그것은 단지 메모리의 모든 주소가 32 비트 길이라는 것을 의미합니다. 
 32 비트는 4 바이트입니다. 

Russian: 
 Таким образом, char * составляет четыре или восемь байтов в зависимости от вашей системы. 
 И действительно любые типы данных, и указатель на любые данные 
 Тип, поскольку все указатели являются просто адресами, четыре или восемь байтов. 
 Итак, давайте вернемся к этой диаграмме и сделаем вывод 
 это видео с небольшим упражнением здесь. 
 Итак, вот схема, с которой мы остановились в самом начале видео. 
 Так что же будет, если я скажу * pk = 35? 
 Так что это значит, когда я говорю, * pk = 35? 
 Возьми секунду. 
 * Рк. 
 В данном контексте * является оператором разыменования. 
 Поэтому, когда используется оператор разыменования, 
 мы идем по адресу, указанному pk, и меняем то, что находим. 
 Так что * pk = 35 эффективно делает это с картиной. 
 Таким образом, это в основном синтаксически идентично тому, чтобы сказать k = 35. 

Chinese: 
所以char *是四个或八个字节，具体取决于您的系统。 
实际上是任何数据类型，以及指向任何数据的指针
类型，因为所有指针只是地址，所以是四个或八个字节。 
因此，让我们回顾一下该图并得出结论
在这里进行一些练习的视频。 
因此，这是我们在视频开始时就忽略的图表。 
那么，如果我说* pk = 35会怎样？ 
那么，当我说* pk = 35时，是什么意思？ 
等一下
 * pk。 
在这里，*是取消引用运算符。 
因此，当使用解引用运算符时， 
我们转到由pk指向的地址，然后更改找到的内容。 
因此，* pk = 35有效地对图片执行了此操作。 
因此，在语法上与说k = 35基本相同。 

Spanish: 
 Entonces un char * es de cuatro u ocho bytes dependiendo de su sistema. 
 Y, de hecho, cualquier tipo de datos y un puntero a cualquier dato 
 tipo, ya que todos los punteros son solo direcciones, son cuatro u ocho bytes. 
 Entonces volvamos a este diagrama y concluyamos 
 Este video con un poco de ejercicio aquí. 
 Así que aquí está el diagrama que dejamos al principio del video. 
 Entonces, ¿qué pasa ahora si digo * pk = 35? 
 Entonces, ¿qué significa cuando digo, * pk = 35? 
 Tómese un segundo 
 * paq. 
 En contexto aquí, * es operador de desreferencia. 
 Entonces, cuando se usa el operador de desreferencia, 
 vamos a la dirección señalada por pk, y cambiamos lo que encontramos. 
 Entonces * pk = 35 efectivamente hace esto a la imagen. 
 Entonces es básicamente sintácticamente idéntico a haber dicho k = 35. 

Turkish: 
 Yani bir char * sisteminize bağlı olarak dört veya sekiz bayttır. 
 Ve aslında herhangi bir veri türü ve herhangi bir veriye bir işaretçi 
 tüm işaretçiler yalnızca adres olduğundan, dört veya sekiz bayttır. 
 Şimdi bu şemayı tekrar gözden geçirelim ve 
 Bu videoda biraz egzersiz yaparak. 
 İşte videonun en başında bıraktığımız şema. 
 Peki * pk = 35 dersem ne olur? 
 Peki, * pk = 35 dediğimde ne anlama geliyor? 
 Bir saniye. 
 * Pk. 
 Burada bağlamda *, dereference operatörüdür. 
 Dereference operatörü kullanıldığında, 
 pk'nin işaret ettiği adrese gidiyoruz ve bulduklarımızı değiştiriyoruz. 
 * Pk = 35 bunu etkili bir şekilde resme yapar. 
 Yani temelde sözdizimsel olarak söz konusu k = 35 ile aynıdır. 

Italian: 
 Quindi un carattere * è di quattro o otto byte a seconda del sistema. 
 E in effetti qualsiasi tipo di dati e un puntatore a qualsiasi dato 
 digitare, poiché tutti i puntatori sono solo indirizzi, sono quattro o otto byte. 
 Quindi rivisitiamo questo diagramma e concludiamo 
 questo video con un piccolo esercizio qui. 
 Quindi, ecco il diagramma con cui abbiamo lasciato all'inizio del video. 
 Cosa succede ora se dico * pk = 35? 
 Quindi cosa significa quando dico, * pk = 35? 
 Prenditi un secondo. 
 * Pk. 
 Nel contesto qui, * è operatore di dereference. 
 Quindi quando viene utilizzato l'operatore di dereference, 
 andiamo all'indirizzo indicato da pk e cambiamo ciò che troviamo. 
 Quindi * pk = 35 lo fa efficacemente all'immagine. 
 Quindi è sostanzialmente sintatticamente identico all'aver detto k = 35. 

Modern Greek (1453-): 
 Επομένως, ένας χαρακτήρας * είναι τέσσερα ή οκτώ bytes ανάλογα με το σύστημά σας. 
 Και όλοι οι τύποι δεδομένων και ένας δείκτης σε οποιαδήποτε δεδομένα 
 επειδή όλοι οι δείκτες είναι μόνο διευθύνσεις, είναι τέσσερις ή οκτώ byte. 
 Ας επανεξετάσουμε αυτό το διάγραμμα και ας ολοκληρώσουμε 
 αυτό το βίντεο με μια μικρή άσκηση εδώ. 
 Έτσι, εδώ είναι το διάγραμμα που σταματήσαμε στην αρχή του βίντεο. 
 Τι συμβαίνει τώρα αν λέω * pk = 35; 
 Τι σημαίνει αυτό όταν λέω, * pk = 35; 
 Πάρτε ένα δευτερόλεπτο. 
 * pk. 
 Στο πλαίσιο αυτό, * είναι ο χειριστής dereference. 
 Έτσι, όταν χρησιμοποιείται ο χειριστής dereference, 
 πηγαίνουμε στη διεύθυνση που υποδεικνύει το pk και αλλάζουμε αυτό που βρίσκουμε. 
 Έτσι * pk = 35 κάνει πραγματικά αυτό στην εικόνα. 
 Επομένως είναι ουσιαστικά συντακτικά πανομοιότυπο με το να είπα k = 35. 

French: 
 Un char * fait donc quatre ou huit octets selon votre système. 
 Et en effet, tous les types de données, et un pointeur vers toutes les données 
 type, puisque tous les pointeurs ne sont que des adresses, sont de quatre ou huit octets. 
 Revoyons donc ce diagramme et concluons 
 cette vidéo avec un petit exercice ici. 
 Voici donc le diagramme que nous avons laissé au tout début de la vidéo. 
 Alors, que se passe-t-il maintenant si je dis * pk = 35? 
 Alors qu'est-ce que cela signifie quand je dis: * pk = 35? 
 Prenez une seconde. 
 * pk. 
 Dans le contexte ici, * est l'opérateur de déréférence. 
 Ainsi, lorsque l'opérateur de déréférence est utilisé, 
 nous allons à l'adresse indiquée par pk, et nous changeons ce que nous trouvons. 
 Donc * pk = 35 fait effectivement cela à l'image. 
 Il est donc fondamentalement syntaxiquement identique à d'avoir dit k = 35. 

Indonesian: 
 Jadi char * adalah empat atau delapan byte tergantung pada sistem Anda. 
 Dan memang ada tipe data, dan pointer ke data apa pun 
 ketik, karena semua pointer hanya alamat, adalah empat atau delapan byte. 
 Jadi mari kita kembali diagram ini dan mari kita simpulkan 
 video ini dengan sedikit latihan di sini. 
 Jadi, inilah diagram yang kami tinggalkan di awal video. 
 Jadi apa yang terjadi sekarang jika saya katakan * pk = 35? 
 Jadi apa artinya ketika saya berkata, * pk = 35? 
 Tunggu sebentar. 
 * pk. 
 Dalam konteks di sini, * adalah operator dereference. 
 Jadi ketika operator dereference digunakan, 
 kita pergi ke alamat yang ditunjuk oleh pk, dan kita mengubah apa yang kita temukan. 
 Jadi * pk = 35 secara efektif melakukan ini pada gambar. 
 Jadi pada dasarnya secara sintaksis identik dengan kata k = 35. 

Korean: 
 따라서 char *는 시스템에 따라 4 또는 8 바이트입니다. 
 실제로 모든 데이터 유형과 모든 데이터에 대한 포인터 
 type은 모든 포인터가 주소 일 뿐이므로 4 바이트 또는 8 바이트입니다. 
 이 다이어그램을 다시 살펴보고 결론을 봅시다. 
 여기에 약간의 운동으로이 비디오가 있습니다. 
 비디오 시작 부분에서 우리가 그만 둔 다이어그램이 있습니다. 
 * pk = 35라고 말하면 어떻게 되나요? 
 * pk = 35라고 말할 때의 의미는 무엇입니까? 
 잠깐만 
 * pk. 
 여기에서 *는 역 참조 연산자입니다. 
 역 참조 연산자를 사용하면 
 우리는 pk가 가리키는 주소로 가서 찾은 것을 변경합니다. 
 따라서 * pk = 35는이를 효과적으로 사진에 적용합니다. 
 따라서 기본적으로 k = 35라고하는 것과 구문 상 동일합니다. 

Arabic: 
 لذا فإن حرف * هو أربعة أو ثمانية بايت حسب نظامك. 
 وبالفعل أي أنواع بيانات ، ومؤشر لأي بيانات 
 اكتب ، لأن جميع المؤشرات مجرد عناوين ، هي أربعة أو ثمانية بايت. 
 لذلك دعونا نعيد النظر في هذا الرسم البياني ونختتم 
 هذا الفيديو مع القليل من التمرين هنا. 
 إذن هذا هو الرسم البياني الذي تركناه مع بداية الفيديو. 
 فماذا يحدث الآن إذا قلت * pk = 35؟ 
 فماذا يعني عندما أقول ، * pk = 35؟ 
 خذ ثانية. 
 * ص. 
 في السياق هنا ، * عامل تشغيل الإشارة. 
 لذلك عندما يتم استخدام عامل الاشارة ، 
 نذهب إلى العنوان المشار إليه بـ pk ونغير ما نجده. 
 لذا * pk = 35 يفعل ذلك بشكل فعال في الصورة. 
 لذا فهي في الأساس مطابقة من الناحية النحوية لقول k = 35. 

Portuguese: 
 Portanto, um caractere * tem quatro ou oito bytes, dependendo do seu sistema. 
 E, de fato, qualquer tipo de dado e um ponteiro para qualquer dado 
 O tipo, como todos os ponteiros são apenas endereços, tem quatro ou oito bytes. 
 Então, vamos revisitar este diagrama e concluir 
 este vídeo com um pouco de exercício aqui. 
 Então, aqui está o diagrama que paramos no início do vídeo. 
 Então, o que acontece agora se eu disser * pk = 35? 
 Então, o que significa quando digo * pk = 35? 
 Tome um segundo. 
 * pk. 
 No contexto aqui, * é um operador de desreferência. 
 Portanto, quando o operador de desreferência é usado, 
 vamos para o endereço indicado por pk e mudamos o que encontramos. 
 Então * pk = 35 efetivamente faz isso na imagem. 
 Portanto, é basicamente sintaticamente idêntico a ter dito k = 35. 

Japanese: 
したがって、char *は、システムに応じて4バイトまたは8バイトです。 
そして実際、あらゆるデータ型とあらゆるデータへのポインタ
タイプは、すべてのポインタが単なるアドレスであるため、4バイトまたは8バイトです。 
それでは、この図に戻って結論を出しましょう
ここで少し練習したこのビデオ。 
これが、ビデオの冒頭で省略した図です。 
では、* pk = 35と言ったらどうなりますか？ 
では、* pk = 35とはどういう意味ですか？ 
ちょっと待って。 
 * pk。 
ここでのコンテキストでは、*は逆参照演算子です。 
したがって、間接参照演算子を使用すると、 
 pkが指すアドレスに移動し、検索結果を変更します。 
したがって、* pk = 35はこれを効果的に画像に適用します。 
したがって、基本的には、k = 35と同じです。 

Dutch: 
 Dus een teken * is vier of acht bytes, afhankelijk van je systeem. 
 En inderdaad alle gegevenstypen en een aanwijzer naar alle gegevens 
 type, aangezien alle verwijzingen slechts adressen zijn, zijn vier of acht bytes. 
 Dus laten we dit diagram opnieuw bekijken en besluiten 
 deze video met een beetje oefening hier. 
 Dus hier is het diagram waarmee we aan het begin van de video waren gebleven. 
 Dus wat gebeurt er nu als ik * pk = 35 zeg? 
 Dus wat betekent het als ik zeg, * pk = 35? 
 Neem even de tijd. 
 * pk. 
 In de context hier is * de dereferentie-operator. 
 Dus als de dereferentie-operator wordt gebruikt, 
 we gaan naar het adres waar pk naar verwijst, en we veranderen wat we vinden. 
 Dus * pk = 35 doet dit effectief voor de foto. 
 Dus het is in wezen syntactisch identiek aan het hebben van k = 35. 

German: 
 Ein Zeichen * besteht also je nach System aus vier oder acht Bytes. 
 Und in der Tat alle Datentypen und ein Zeiger auf alle Daten 
 Typ, da alle Zeiger nur Adressen sind, sind vier oder acht Bytes. 
 Schauen wir uns dieses Diagramm noch einmal an und schließen wir 
 Dieses Video mit einer kleinen Übung hier. 
 Hier ist das Diagramm, mit dem wir ganz am Anfang des Videos aufgehört haben. 
 Was passiert nun, wenn ich * pk = 35 sage? 
 Was bedeutet es also, wenn ich sage: * pk = 35? 
 Nehmen Sie sich eine Sekunde Zeit. 
 * pk. 
 Im Kontext hier ist * der Dereferenzierungsoperator. 
 Wenn also der Dereferenzierungsoperator verwendet wird, 
 Wir gehen zu der Adresse, auf die pk zeigt, und ändern, was wir finden. 
 * Pk = 35 macht dies also effektiv mit dem Bild. 
 Es ist also im Grunde syntaktisch identisch mit dem k = 35. 

English: 
So a char * is four or eight bytes depending on your system.
And indeed any data types, and a pointer to any data
type, since all pointers are just addresses, are four or eight bytes.
So let's revisit this diagram and let's conclude
this video with a little exercise here.
So here's the diagram we left off with at the very beginning of the video.
So what happens now if I say *pk=35?
So what does it mean when I say, *pk=35?
Take a second.
*pk.
In context here, * is dereference operator.
So when the dereference operator is used,
we go to the address pointed to by pk, and we change what we find.
So *pk=35 effectively does this to the picture.
So it's basically syntactically identical to of having said k=35.

Chinese: 
所以char *是四個或八個字節，具體取決於您的系統。 
實際上是任何數據類型，以及指向任何數據的指針
類型，因為所有指針只是地址，所以是四個或八個字節。 
因此，讓我們回顧一下該圖並得出結論
在這裡進行一些練習的視頻。 
因此，這是我們在視頻開始時就忽略的圖表。 
那麼，如果我說* pk = 35會怎樣？ 
那麼，當我說* pk = 35時，是什麼意思？ 
等一下
 * pk。 
在這裡，*是取消引用運算符。 
因此，當使用解引用運算符時， 
我們轉到由pk指向的地址，然後更改找到的內容。 
因此，* pk = 35有效地對圖片執行了此操作。 
因此，在語法上與說k = 35基本相同。 

Hindi: 
 तो एक चार * चार या आठ बाइट्स आपके सिस्टम पर निर्भर करता है। 
 और वास्तव में किसी भी डेटा प्रकार, और किसी भी डेटा के लिए एक सूचक 
 प्रकार, चूंकि सभी संकेत केवल पते हैं, चार या आठ बाइट्स हैं। 
 तो चलिए इस आरेख पर फिर से विचार करते हैं और निष्कर्ष निकालते हैं 
 इस वीडियो के साथ यहां थोड़ा व्यायाम करें। 
 तो यहाँ आरेख हमने वीडियो की शुरुआत में ही छोड़ दिया है। 
 तो अब क्या होता है अगर मैं कहता हूं कि * pk = 35? 
 तो इसका क्या मतलब है जब मैं कहता हूं, * pk = 35? 
 एक सेकेंड लो। 
 * पी। 
 यहाँ के संदर्भ में, * परिचालक ऑपरेटर है। 
 इसलिए जब डेरेफेरेंस ऑपरेटर का उपयोग किया जाता है, 
 हम pk द्वारा बताए गए पते पर जाते हैं, और हम जो पाते हैं उसे बदल देते हैं। 
 तो * pk = 35 इस चित्र को प्रभावी ढंग से करता है। 
 तो यह मूल रूप से वाक्यगत रूप से k = 35 होने के समान है। 

Chinese: 
 >>還有一個。 
如果我說int m，則創建一個名為m的新變量。 
一個新盒子，一個綠色盒子，因為它將容納一個整數， 
並標有m。 
如果我說m = 4，我在那個盒子裡放一個整數。 
如果說pk =＆m，此圖如何更改？ 
 Pk =＆m，您還記得＆運算符做什麼或被叫什麼嗎？ 
記住＆變量名是變量名的地址。 
因此，我們要說的是pk獲取m的地址。 
如此有效地發生了該圖，就是pk不再指向
到k，但指向m。 
 >>同樣，指針非常棘手
他們需要很多練習，但是因為
允許您在函數之間傳遞數據的能力
並使這些更改生效
振作起來真的很重要。 

Indonesian: 
 >> Satu lagi. 
 Jika saya katakan int m, saya membuat variabel baru bernama m. 
 Kotak baru, ini kotak hijau karena akan menyimpan bilangan bulat, 
 dan ini berlabel m. 
 Jika saya katakan m = 4, saya memasukkan integer ke dalam kotak itu. 
 Jika katakan pk = & m, bagaimana diagram ini berubah? 
 Pk = & m, apakah Anda ingat apa yang dilakukan operator & atau dipanggil? 
 Ingat bahwa & beberapa nama variabel adalah alamat nama variabel. 
 Jadi yang kami katakan adalah pk mendapat alamat m. 
 Dan begitu efektif apa yang terjadi diagram adalah bahwa pk tidak lagi menunjuk 
 ke k, tetapi menunjuk ke m. 
 >> Sekali lagi pointer sangat sulit untuk dikerjakan 
 dan mereka mengambil banyak latihan, tetapi karena 
 kemampuan mereka untuk memungkinkan Anda mengirim data antar fungsi 
 dan benar-benar membuat perubahan itu berlaku, 
 membawa kepalamu benar-benar penting. 

Portuguese: 
 >> Mais um. 
 Se eu disser int m, crio uma nova variável chamada m. 
 Uma nova caixa, é uma caixa verde porque vai conter um número inteiro, 
 e está rotulado como m. 
 Se eu disser m = 4, coloco um número inteiro nessa caixa. 
 Se digamos pk = & m, como esse diagrama muda? 
 Pk = & m, você se lembra como o operador & faz ou é chamado? 
 Lembre-se de que & algum nome de variável é o endereço de um nome de variável. 
 Então, o que estamos dizendo é que pk obtém o endereço de m. 
 E tão efetivamente o que acontece no diagrama é que pk não aponta mais 
 para k, mas aponta para m. 
 >> Novamente, os ponteiros são muito complicados de se trabalhar 
 e eles praticam muita prática, mas porque 
 de sua capacidade de permitir que você passe dados entre funções 
 e, na verdade, essas alterações entram em vigor, 
 mexer com a cabeça é realmente importante. 

Italian: 
 >> Ancora uno. 
 Se dico int m, creo una nuova variabile chiamata m. 
 Una nuova casella, è una casella verde perché conterrà un numero intero, 
 ed è etichettato m. 
 Se dico m = 4, inserisco un numero intero in quella casella. 
 Se dire pk = & m, come cambia questo diagramma? 
 Pk = & m, ricordi cosa fa o viene chiamato l'operatore &? 
 Ricorda che un nome variabile è l'indirizzo di un nome variabile. 
 Quindi quello che stiamo dicendo è che pk ottiene l'indirizzo di m. 
 E così efficacemente ciò che accade nel diagramma è che pk non punta più 
 a k, ma indica m. 
 >> Ancora una volta i puntatori sono molto difficili da lavorare 
 e prendono molta pratica, ma perché 
 della loro capacità di consentire il passaggio di dati tra le funzioni 
 e effettivamente queste modifiche hanno effetto, 
 capovolgere è davvero importante. 

English: 
>> One more.
If I say int m, I create a new variable called m.
A new box, it's a green box because it's going to hold an integer,
and it's labeled m.
If I say m=4, I put an integer into that box.
If say pk=&m, how does this diagram change?
Pk=&m, do you recall what the & operator does or is called?
Remember that & some variable name is the address of a variable name.
So what we're saying is pk gets the address of m.
And so effectively what happens the diagram is that pk no longer points
to k, but points to m.
>> Again pointers are very tricky to work with
and they take a lot of practice, but because
of their ability to allow you to pass data between functions
and actually have those changes take effect,
getting your head around is really important.

Hindi: 
 >> एक और। 
 अगर मैं int m कहता हूं, तो मैं एक नया चर बनाता हूं जिसे m कहा जाता है। 
 एक नया बॉक्स, यह एक हरे रंग का बॉक्स है क्योंकि यह पूर्णांक को धारण करने वाला है, 
 और यह एम लेबल है। 
 यदि मैं m = 4 कहता हूं, तो मैं उस बॉक्स में एक पूर्णांक रखता हूं। 
 यदि pk = & m कहें, तो यह आरेख कैसे बदलता है? 
 Pk = & m, क्या आपको याद है कि & ऑपरेटर क्या करता है या कहा जाता है? 
 याद रखें कि और कुछ चर नाम एक चर नाम का पता है। 
 तो हम जो कह रहे हैं वह p का पता है। 
 और इतनी प्रभावी रूप से क्या होता है आरेख कि पीके अब अंक नहीं है 
 k को, लेकिन मी को इंगित करता है। 
 >> फिर से संकेत के साथ काम करने के लिए बहुत मुश्किल हैं 
 और वे बहुत अभ्यास करते हैं, लेकिन क्योंकि 
 आप कार्य के बीच डेटा पारित करने के लिए अनुमति देने की उनकी क्षमता 
 और वास्तव में उन बदलावों का असर होता है, 
 अपने सिर के आसपास हो रही वास्तव में महत्वपूर्ण है। 

Arabic: 
 >> واحد آخر. 
 إذا قلت int m ، أقوم بإنشاء متغير جديد يسمى m. 
 صندوق جديد ، إنه صندوق أخضر لأنه سيحتوي على عدد صحيح ، 
 ويسمى م. 
 إذا قلت m = 4 ، أضع عددًا صحيحًا في هذا المربع. 
 إذا قل pk = & m ، كيف يتغير هذا الرسم البياني؟ 
 Pk = & m ، هل تتذكر ما يفعله أو يطلق عليه عامل التشغيل؟ 
 تذكر أن & بعض اسم المتغير هو عنوان اسم متغير. 
 لذا ما نقوله هو pk يحصل على عنوان m. 
 وما يحدث بشكل فعال في الرسم البياني هو أن pk لم يعد يشير 
 إلى ك ، ولكن يشير إلى م. 
 >> مرة أخرى ، المؤشرات صعبة للغاية للعمل معها 
 ويأخذون الكثير من التدريب ، ولكن بسبب 
 من قدرتها على السماح لك بتمرير البيانات بين الوظائف 
 وتفعيل هذه التغييرات ، 
 الحصول على رأسك أمر مهم حقا. 

Modern Greek (1453-): 
 >> Ένας ακόμα. 
 Αν λέω int m, δημιουργώ μια νέα μεταβλητή που ονομάζεται m. 
 Ένα νέο κουτί, είναι ένα πράσινο κιβώτιο επειδή πρόκειται να κρατήσει έναν ακέραιο αριθμό, 
 και είναι ετικέτα m. 
 Αν λέω m = 4, βάζω έναν ακέραιο σε αυτό το κιβώτιο. 
 Αν πούμε pk = & m, πώς αλλάζει αυτό το διάγραμμα; 
 Pk = & m, θυμάστε τι ο χειριστής & ο χρήστης κάνει ή καλείται; 
 Να θυμάστε ότι & κάποιο όνομα μεταβλητής είναι η διεύθυνση ενός ονόματος μεταβλητής. 
 Λοιπόν αυτό που λέμε είναι το pk παίρνει τη διεύθυνση του m. 
 Και τόσο αποτελεσματικά αυτό που συμβαίνει στο διάγραμμα είναι ότι το pk δεν δείχνει πια 
 στο k, αλλά δείχνει στο m. 
 >> Και πάλι οι δείκτες είναι πολύ δύσκολο να συνεργαστεί 
 και παίρνουν πολλή πρακτική, αλλά επειδή 
 της ικανότητάς τους να σας επιτρέπουν να μεταφέρετε δεδομένα μεταξύ λειτουργιών 
 και πραγματικά έχουν αυτές οι αλλαγές να ισχύουν, 
 να πάρει το κεφάλι σας γύρω είναι πολύ σημαντικό. 

Russian: 
 >> Еще один. 
 Если я скажу int m, я создам новую переменную с именем m. 
 Новый ящик, это зеленый ящик, потому что он будет содержать целое число, 
 и это помечено м. 
 Если я скажу m = 4, я положу в это поле целое число. 
 Если сказать pk = & m, как изменится эта диаграмма? 
 Pk = & m, вы помните, что оператор & делает или называется? 
 Помните, что & некоторое имя переменной является адресом имени переменной. 
 Итак, мы говорим, что pk получает адрес m. 
 И так эффективно, что происходит на диаграмме, что ПК больше не указывает 
 к, но указывает на м. 
 >> Опять же, с указателями очень сложно работать 
 и они занимают много практики, но потому что 
 их способность позволять вам передавать данные между функциями 
 и на самом деле эти изменения вступают в силу, 
 очень важно иметь голову. 

Korean: 
 >> 하나 더. 
 int m이라고하면 m이라는 새 변수를 만듭니다. 
 새 상자는 정수를 보유 할 것이기 때문에 녹색 상자입니다. 
 그리고 m이라고 표시되어 있습니다. 
 m = 4라고하면 정수를 해당 상자에 넣습니다. 
 pk = & m이라고하면이 다이어그램은 어떻게 변경됩니까? 
 Pk = & m, & 연산자가 무엇을하는지 또는 호출되는 것을 기억하십니까? 
 & 일부 변수 이름은 변수 이름의 주소입니다. 
 우리가 말하는 것은 pk가 m의 주소를 얻는다는 것입니다. 
 그리고 효과적으로 다이어그램이 일어나는 것은 pk가 더 이상 지적하지 않습니다. 
 k를 나타내지 만 m을 가리 킵니다. 
 >> 포인터는 작업하기가 매우 까다 롭습니다. 
 많은 연습이 필요하지만 
 기능간에 데이터를 전달할 수있는 기능 
 실제로 이러한 변경 사항이 적용되도록 
 머리를 돌리는 것이 정말 중요합니다. 

Spanish: 
 >> Uno más. 
 Si digo int m, creo una nueva variable llamada m. 
 Una nueva caja, es una caja verde porque va a contener un número entero, 
 y está etiquetado m. 
 Si digo m = 4, pongo un número entero en ese cuadro. 
 Si dice pk = & m, ¿cómo cambia este diagrama? 
 Pk = & m, ¿recuerda lo que hace o llama el operador &? 
 Recuerde que & algún nombre de variable es la dirección de un nombre de variable. 
 Entonces, lo que estamos diciendo es que pk obtiene la dirección de m. 
 Y tan efectivamente lo que sucede el diagrama es que pk ya no apunta 
 a k, pero apunta a m. 
 >> De nuevo, es muy difícil trabajar con punteros 
 y toman mucha práctica, pero porque 
 de su capacidad para permitirle pasar datos entre funciones 
 y que esos cambios surtan efecto, 
 entenderlo es realmente importante. 

French: 
 >> Un de plus. 
 Si je dis int m, je crée une nouvelle variable appelée m. 
 Une nouvelle boîte, c'est une boîte verte parce qu'elle va contenir un entier, 
 et il est étiqueté m. 
 Si je dis m = 4, je mets un entier dans cette case. 
 Si disons pk = & m, comment ce diagramme change-t-il? 
 Pk = & m, vous souvenez-vous de ce que l'opérateur & fait ou s'appelle? 
 N'oubliez pas que & un nom de variable est l'adresse d'un nom de variable. 
 Donc, ce que nous disons, c'est que pk obtient l'adresse de m. 
 Et si efficacement ce qui se passe, le diagramme est que pk ne pointe plus 
 à k, mais pointe vers m. 
 >> Encore une fois, les pointeurs sont très difficiles à utiliser 
 et ils prennent beaucoup de pratique, mais parce que 
 de leur capacité à vous permettre de transmettre des données entre les fonctions 
 et que ces changements prennent effet, 
 il est vraiment important de se déplacer la tête. 

German: 
 >> Noch eine. 
 Wenn ich int m sage, erstelle ich eine neue Variable namens m. 
 Eine neue Box, es ist eine grüne Box, weil sie eine ganze Zahl enthalten wird. 
 und es ist m beschriftet. 
 Wenn ich m = 4 sage, gebe ich eine ganze Zahl in dieses Feld ein. 
 Wenn Sie pk = & m sagen, wie ändert sich dieses Diagramm? 
 Pk = & m, erinnerst du dich daran, was der Operator & tut oder heißt? 
 Denken Sie daran, dass & ein Variablenname die Adresse eines Variablennamens ist. 
 Wir sagen also, dass pk die Adresse von m erhält. 
 Und so effektiv passiert das Diagramm, dass pk nicht mehr zeigt 
 zu k, zeigt aber auf m. 
 >> Auch hier ist es sehr schwierig, mit Zeigern zu arbeiten 
 und sie brauchen viel Übung, aber weil 
 von ihrer Fähigkeit, Ihnen zu ermöglichen, Daten zwischen Funktionen zu übertragen 
 und tatsächlich diese Änderungen wirksam werden lassen, 
 Es ist wirklich wichtig, den Kopf herumzukriegen. 

Japanese: 
 >>もう1つ。 
 int mと言うと、mという新しい変数を作成します。 
新しいボックスです。整数を保持するため、緑色のボックスです。 
そして、それはmとラベル付けされています。 
私がm = 4と言う場合、そのボックスに整数を入れます。 
 pk =＆mと言うと、この図はどのように変化しますか？ 
 Pk =＆m、＆演算子の機能または呼び出された機能を覚えていますか？ 
 ＆一部の変数名は変数名のアドレスであることを忘れないでください。 
つまり、pkはmのアドレスを取得します。 
そして、効果的に図が起こるのは、pkがもはやポイントしないことです
 to k、ただしmを指す。 
 >>ポインターを操作するのは非常に難しいです
彼らは多くの練習をしますが
関数間でデータを受け渡すことができる機能の
実際にこれらの変更を有効にします
頭を動かすことは本当に重要です。 

Dutch: 
 >> Nog een. 
 Als ik int m zeg, maak ik een nieuwe variabele met de naam m. 
 Een nieuw vak, het is een groen vak omdat het een geheel getal zal bevatten, 
 en het is gelabeld m. 
 Als ik m = 4 zeg, plaats ik een geheel getal in dat vak. 
 Als zeg pk = & m, hoe verandert dit diagram dan? 
 Pk = & m, weet je nog wat de & -operator doet of wordt genoemd? 
 Onthoud dat & een variabele naam het adres is van een variabelenaam. 
 Dus wat we zeggen is dat pk het adres van m krijgt. 
 En zo effectief is het diagram dat pk niet langer wijst 
 tot k, maar wijst naar m. 
 >> Opnieuw zijn aanwijzers erg lastig om mee te werken 
 en ze hebben veel oefening nodig, maar omdat 
 van hun vermogen om gegevens tussen functies door te geven 
 en die wijzigingen daadwerkelijk doorvoeren, 
 je hoofd rond krijgen is echt belangrijk. 

Turkish: 
 >> Bir tane daha. 
 İnt m dersem, m adında yeni bir değişken oluştururum. 
 Yeni bir kutu, yeşil bir kutu çünkü bir tamsayı tutacak, 
 ve m olarak etiketlenmiştir. 
 M = 4 dersem, bu kutuya bir tamsayı koyarım. 
 Pk = & m derseniz, bu diyagram nasıl değişir? 
 Pk = & m, & operatörünün ne yaptığını veya çağrıldığını hatırlıyor musunuz? 
 Unutmayın & bazı değişken adları değişken adının adresidir. 
 Demek istediğimiz pk m adresini alır. 
 Ve o kadar etkili bir şema olur ki pk artık işaret etmiyor 
 k olur, ancak m'yi gösterir. 
 >> İşaretçilerle çalışmak çok zor 
 ve çok pratik yapıyorlar, çünkü 
 verileri işlevler arasında geçirmenize izin verme yeteneklerinin 
 ve aslında bu değişikliklerin yürürlüğe girmesini sağlayın, 
 başını döndürmek gerçekten çok önemli. 

Chinese: 
 >>还有一个。 
如果我说int m，则创建一个名为m的新变量。 
一个新盒子，一个绿色盒子，因为它将容纳一个整数， 
并标有m。 
如果我说m = 4，我在那个盒子里放一个整数。 
如果说pk =＆m，此图如何更改？ 
 Pk =＆m，您还记得＆运算符做什么或被叫什么吗？ 
记住＆变量名是变量名的地址。 
因此，我们要说的是pk获取m的地址。 
如此有效地发生了该图，就是pk不再指向
到k，但指向m。 
 >>同样，指针非常棘手
他们需要很多练习，但是因为
允许您在函数之间传递数据的能力
并使这些更改生效
振作起来真的很重要。 

French: 
 C'est probablement le sujet le plus compliqué dont nous discutons dans CS50, 
 mais la valeur que vous obtenez en utilisant des pointeurs 
 l'emporte de loin sur les complications qui découlent de leur apprentissage. 
 Je vous souhaite donc la meilleure des chances d'apprendre les pointeurs. 
 Je m'appelle Doug Lloyd, voici CS50. 

Russian: 
 Это, наверное, самая сложная тема, которую мы обсуждаем в CS50, 
 но ценность, которую вы получаете от использования указателей 
 намного перевешивает осложнения, которые возникают при их изучении. 
 Поэтому я желаю вам удачи в изучении указателей. 
 Я Даг Ллойд, это CS50. 

Japanese: 
これは、おそらくCS50で説明する最も複雑なトピックです。 
しかし、ポインタを使用して得られる値
それらを学ぶことから来る複雑さをはるかに上回ります。 
だから、私はあなたがポインタについて学ぶ幸運を祈ります。 
ダグ・ロイドです。CS50です。 

Dutch: 
 Het is waarschijnlijk het meest gecompliceerde onderwerp dat we in CS50 bespreken, 
 maar de waarde die je krijgt door pointers te gebruiken 
 weegt veel zwaarder dan de complicaties die voortvloeien uit het leren ervan. 
 Dus ik wens je veel succes met het leren over pointers. 
 Ik ben Doug Lloyd, dit is CS50. 

Portuguese: 
 Provavelmente é o tópico mais complicado que discutimos no CS50, 
 mas o valor que você obtém ao usar ponteiros 
 supera em muito as complicações decorrentes de aprendê-las. 
 Então, desejo a você boa sorte aprendendo sobre indicadores. 
 Eu sou Doug Lloyd, este é o CS50. 

Turkish: 
 Muhtemelen CS50'de tartıştığımız en karmaşık konu, 
 ancak işaretçileri kullanarak elde ettiğiniz değer 
 onları öğrenmekten kaynaklanan komplikasyonlardan çok daha ağır basar. 
 Bu yüzden size işaretçiler hakkında iyi şanslar diliyorum. 
 Ben Doug Lloyd, bu CS50. 

Chinese: 
這可能是我們在CS50中討論的最複雜的話題， 
但是您從使用指針獲得的價值
遠遠超過了學習它們所帶來的複雜性。 
因此，祝您好運學習指針。 
我是道格·勞埃德（Doug Lloyd），這是CS50。 

Spanish: 
 Probablemente es el tema más complicado que discutimos en CS50, 
 pero el valor que obtienes al usar punteros 
 supera con creces las complicaciones que surgen de aprenderlas. 
 Así que les deseo la mejor de las suertes aprendiendo sobre punteros. 
 Soy Doug Lloyd, esto es CS50. 

Modern Greek (1453-): 
 Είναι πιθανόν το πιο περίπλοκο θέμα που συζητάμε στο CS50, 
 αλλά η αξία που παίρνετε από τη χρήση δείκτες 
 υπερβαίνουν κατά πολύ τις επιπλοκές που προέρχονται από την εκμάθησή τους. 
 Σας εύχομαι καλή τύχη να μάθετε για τους δείκτες. 
 Είμαι ο Doug Lloyd, αυτό είναι CS50. 

Indonesian: 
 Mungkin ini adalah topik paling rumit yang kita bahas di CS50, 
 tetapi nilai yang Anda dapatkan dari menggunakan pointer 
 jauh melebihi komplikasi yang datang dari mempelajarinya. 
 Jadi saya berharap yang terbaik dari keberuntungan belajar tentang petunjuk. 
 Saya Doug Lloyd, ini CS50. 

Korean: 
 CS50에서 가장 복잡한 주제 일 것입니다. 
 그러나 포인터를 사용하여 얻는 가치 
 그것을 배우는 데 따른 합병증보다 훨씬 큽니다. 
 그래서 포인터에 대해 배우는 것이 가장 좋습니다. 
 저는 Doug Lloyd입니다. CS50입니다. 

English: 
It probably is the most complicated topic we discuss in CS50,
but the value that you get from using pointers
far outweighs the complications that come from learning them.
So I wish you the best of luck learning about pointers.
I'm Doug Lloyd, this is CS50.

German: 
 Es ist wahrscheinlich das komplizierteste Thema, das wir in CS50 diskutieren. 
 aber der Wert, den Sie durch die Verwendung von Zeigern erhalten 
 überwiegt bei weitem die Komplikationen, die durch das Lernen entstehen. 
 Ich wünsche Ihnen viel Glück beim Erlernen von Zeigern. 
 Ich bin Doug Lloyd, das ist CS50. 

Hindi: 
 यह शायद सबसे जटिल विषय है जिसकी हम CS50 में चर्चा करते हैं, 
 लेकिन वह मूल्य जो आपको पॉइंटर्स का उपयोग करने से मिलता है 
 उन जटिलताओं को दूर करता है जो उन्हें सीखने से आती हैं। 
 इसलिए मैं आपको शुभकामनाएं देता हूं कि आप संकेत के बारे में सीखें। 
 मैं डौग लॉयड हूं, यह CS50 है। 

Italian: 
 È probabilmente l'argomento più complicato di cui discutiamo in CS50, 
 ma il valore che si ottiene dall'uso dei puntatori 
 supera di gran lunga le complicazioni che derivano dall'apprenderle. 
 Quindi ti auguro buona fortuna per conoscere i puntatori. 
 Sono Doug Lloyd, questo è CS50. 

Arabic: 
 ربما يكون الموضوع الأكثر تعقيدًا الذي نناقشه في CS50 ، 
 ولكن القيمة التي تحصل عليها من استخدام المؤشرات 
 تفوق بكثير التعقيدات التي تأتي من تعلمهم. 
 لذا أتمنى لك حظًا سعيدًا في التعرف على المؤشرات. 
 أنا دوغ لويد ، هذا CS50. 

Chinese: 
这可能是我们在CS50中讨论的最复杂的话题， 
但是您从使用指针获得的价值
远远超过了学习它们所带来的复杂性。 
因此，祝您好运学习指针。 
我是道格·劳埃德（Doug Lloyd），这是CS50。 
