
Malayalam: 
സി പ്ലസ് പ്ലസിലെ
ഈ മൊഡ്യൂളിലേക്ക്
സ്വാഗതം. സി പ്ലസ്
പ്ലസിലേക്ക് ഒരു
ദ്രുത ആമുഖം കാണാമെന്ന്
ഞാൻ നേരത്തെ പറഞ്ഞു.
ഈ മെറ്റീരിയൽ നിങ്ങൾക്ക്
മതിയായ രീതിയിൽ നൽകും.
ബാക്കി കോഴ്സിൽ എന്താണ്
സംഭവിക്കുന്നതെന്ന്
മനസിലാക്കാനുള്ള
മെറ്റീരിയൽ.
ഈ മൊഡ്യൂളിൽ (module) സി
പ്ലസ് പ്ലസിലെ (C++)
എല്ലാ കാര്യങ്ങളും
പറയുന്നില്ല. സി
പ്ലസ് പ്ലസ് (C++) ഒരു
വിശാലമായ സമുദ്രമാണ്,
ഈ അടുത്ത 15 അല്ലെങ്കിൽ
20 മിനിറ്റ് കൊണ്ട്
എല്ലാം പറയാൻ കഴിയില്ല
അതിനാൽ, ഇത് പൂർണ്ണമല്ല.
ഈ 15 മിനിറ്റ് മൊഡ്യൂളിൽ
(module) ധാരാളം ഒബ്ജക്റ്റ്
ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ്
(object oriented programming) കഴിവുകൾ
പഠിക്കുമെന്ന് പ്രതീക്ഷിക്കരുത്.
സി പ്ലസ് പ്ലസിന്റെ
(C++) സിന്റാക്സ് (syntax)
പഠിക്കാൻ മതിയായ
മെറ്റീരിയൽ (material)
മാത്രമേ ഉണ്ടാകൂ,
അടിസ്ഥാന മെറ്റീരിയൽ
(material) സ്ട്രോസ്ട്രപ്പിന്റെ

Hindi: 
आह .. सी प्लस प्लस
पर इस मॉड्यूल में
आपका स्वागत है।
आह .. मैंने पहले वादा
किया था कि हम सी प्लस
प्लस के साथ एक त्वरित
परिचय देखेंगे और
यह सामग्री इस तरह
से की जाती है कि,
यह आपको बस पर्याप्त
आह दे देगा .. यह समझने
के लिए सामग्री कि
बाकी कोर्स में क्या
हो रहा है।
तो, मैं एक अस्वीकरण
के साथ शुरू करूंगा।
यह मॉड्यूल C प्लस
प्लस पर पूर्ण उपचार
नहीं है।
सी प्लस प्लस एक विशाल
महासागर है और यह

English: 
Hello, ah.. welcome to this module on C plus
plus.
ah..
I promised earlier that we will see a quick
introduction to C plus plus and this material
is done in such a way that, it will give you
just enough ah.. material to understand what
is happening in the rest of the course.
So, I will start with a disclaimer.
This this module is not a complete treatment
on C plus plus.
C plus plus is a vast ocean and this next
15 or 20 minutes is not going to give enough
justice to C plus plus.
So, its not a complete ah.. exhaustive treatment
of C plus plus.
Also, do not expect a lot of object oriented
programming skills, to be learnt in this 15
minute module, right.

Hindi: 
अगले 15 या 20 मिनट सी
प्लस प्लस को पर्याप्त
न्याय नहीं देने
वाला है।
तो, इसकी पूरी एक्सहौसतिवे
ट्रीटमंट(exhaustive treatment)
नहीं है।
इसके अलावा, इस 15 मिनट
के मॉड्यूल में सीखने
के लिए बहुत सारे
ऑब्जेक्ट ओरिएंटेड
प्रोग्रामिंग(object
oriented programming) कौशल की
उम्मीद न करें, सही
है।
सी प्लस प्लस के सिंटैक्स
की सराहना करने के
लिए बस पर्याप्त
सामग्री होने जा
रही है और किसी भी
तरह से यह पूरा नहीं
हुआ है।
तो, मूल सामग्री आह
है .. Stroustrup की स्लाइड्स
के आधार पर।
तो, आह .. वह इस पाठ्यक्रम
को सी प्लस प्लस पर
सिखाता है और वह वास्तव
में सी प्लस प्लस
का आविष्कारक है।
तो, कुछ मायने में
यह आह .. घोड़े के मुंह
से है।
तो, क्लाससेस(classes)
और ओब्जेक्ट्स(objects)
की धारणा को देखने
देता है।

Malayalam: 
(Stroustrup) സ്ലൈഡുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.
സി പ്ലസ് പ്ലസിൽ
(C++) ഈ കോഴ്സ് (course) പഠിപ്പിക്കുന്ന
അദ്ദേഹം യഥാർത്ഥത്തിൽ
സി പ്ലസ് പ്ലസിന്റെ
(C++) ഉപജ്ഞാതാവാണ്.
ക്ലാസുകളുടെയും
(class) ഒബ്ജെക്റ്റുകളുടെയും
(object) ആശയം നോക്കാം.
നിങ്ങൾ നിങ്ങളുടെ
ക്ലാസ്സിൽ (class) അല്പം
സീനിയർ വർഷത്തിലാണെങ്കിൽ,
രണ്ടാം വർഷത്തിലോ
മൂന്നാം വർഷത്തിലോ
കുറച്ച് സി പ്ലസ്
പ്ലസ് പ്രോഗ്രാമിംഗ്
(C++ programming) നടത്തിയിരിക്കാം.
ക്ലാസുകളുടെയും
(class) ഒബ്ജെക്റ്റുകളുടെയും
(object) ആശയം നിങ്ങൾക്ക്
ഒരുപക്ഷേ പരിചിതമായിരിക്കും,
പക്ഷേ ഞാൻ അത്തരത്തിലുള്ള
ഒന്നും അനുമാനിക്കാൻ
പോകുന്നില്ല. ക്ലാസുകളും
(class) ഒബ്ജെക്റ്റുകളും
(object) എന്താണെന്ന്
നിങ്ങൾക്ക് അറിയില്ലെന്ന്
ഞാൻ അനുമാനിക്കാൻ
പോകുന്നു. Int x എന്ന്
വിളിക്കുന്ന ഈ അടിസ്ഥാന
പ്രഖ്യാപനത്തിൽ
നിന്ന് ആരംഭിക്കാം.
നമുക്ക് ഒരു ക്ലാസായി
(class) int നെക്കുറിച്ച്
ചിന്തിക്കാം. ഇത്
ഒരു അടിസ്ഥാന ഡാറ്റാ
(data) തരമാണ്, പൂർണ്ണസംഖ്യയാണെന്ന്
നിങ്ങൾക്കറിയാം,

English: 
There is going to be just enough material
to appreciate the syntax of C plus plus and
by no means, it is complete.
So, the basic material is ah.. based on Stroustrup's
slides.
So, ah.. he he teaches this course on C plus
plus and he is actually the inventor of C
plus plus.
So, in some sense this is from ah.. the horse’s
mouth.
So, lets look at the notion of classes and
objects.
So, if you are in slightly senior year in
your class, ah.. in the second year or third
year may be have done some C plus plus programming.
So, the notion of classes and objects are
probably familiar to you, but I am not going
to assume assume anything like that.
So, I am going to assume that you don't know
what classes and objects are.
Lets start with this basic declaration called
int x.
We can think of int as a class.
So, it is a basic data type and the moment
you say something is int or an integer, you
know that, there are certain operations that
you can do on it, and there are certain properties
of integers.

Hindi: 
इसलिए, यदि आप अपनी
कक्षा में थोड़ा
वरिष्ठ वर्ष में
हैं, तो आह .. दूसरे
वर्ष या तीसरे वर्ष
में कुछ सी प्लस प्लस
प्रोग्रामिंग किया
जा सकता है।
तो, क्लाससेस(classes)
और ओब्जेक्ट्स(objects)
की धारणा शायद आप
से परिचित हैं, लेकिन
मैं ऐसा कुछ भी नहीं
मानूंगा।
इसलिए, मैं यह मानने
जा रहा हूं कि आपको
नहीं पता कि क्लाससेस(classes)
और ओब्जेक्ट्स(objects)
क्या हैं।
आइए इस मूल घोषणा
के साथ शुरू करें
जिसे int x कहा जाता
है।
हम इंट को एक क्लास(class)
के रूप में सोच सकते
हैं।
तो, यह एक बुनियादी
डेटा प्रकार है और
जिस क्षण आप कहते
हैं कि कुछ अंतर या
पूर्णांक है, आप जानते
हैं कि, कुछ निश्चित
ऑपरेशन हैं जो आप
इस पर कर सकते हैं,

English: 
So, for example, integers can have only values
like 1, 2, 3, 0, -1, -2, -3 and so, on.
You cannot have a valid value 1.6, right.
So, we know some of these properties about
int.
So, any time when you have something called
a class, you know that there are certain types.
So, there are certain properties of a class
and there are only certain operations that
you can do on the data type.
So, for the basic data types, the language
itself tells you that these are the basic
set of values that you can take, and these
are the valid operations that you can do,
right.
So, thats the notion of our class..
Here if you look at x, x is actually an object,
right.
So, what we mean by an object is, its not
something abstract when I say integer, right.
When I say int, I am I am describing only
the properties that int integers have and
the operations.

Malayalam: 
അതിൽ ചെയ്യാൻ കഴിയുന്ന
ചില പ്രവർത്തനങ്ങൾ
ഉണ്ട്, കൂടാതെ പൂർണ്ണസംഖ്യകളുടെ
ചില സവിശേഷതകളും
ഉണ്ട്. ഉദാഹരണത്തിന്,
പൂർണ്ണസംഖ്യകൾക്ക്
1, 2, 3, 0, -1, -2, -3 എന്നിങ്ങനെയുള്ള
മൂല്യങ്ങൾ മാത്രമേ
ഉണ്ടാകൂ. മൂല്യം
1.6 ആകാൻ കഴിയില്ല.
int നെക്കുറിച്ചുള്ള
ഈ സവിശേഷതകളിൽ ചിലത്
നമുക്കറിയാം. ക്ലാസ്
എന്ന് വിളിക്കപ്പെടുമ്പോൾ,
ചില തരങ്ങളുണ്ടെന്ന്
നിങ്ങൾക്കറിയാം.
ഒരു ക്ലാസിന്റെ ചില
സവിശേഷതകൾ‌ ഉണ്ട്
കൂടാതെ ഡാറ്റാ (data)
തരത്തിൽ‌ ചെയ്യാൻ‌
കഴിയുന്ന ചില പ്രവർ‌ത്തനങ്ങൾ‌
മാത്രമേയുള്ളൂ. അടിസ്ഥാന
ഡാറ്റാ തരങ്ങൾക്കായി,
നിങ്ങൾക്ക് എടുക്കാവുന്ന
മൂല്യങ്ങളുടെ അടിസ്ഥാന
ഗണമാണിതെന്ന് ഭാഷ
തന്നെ നിങ്ങളോട്
പറയുന്നു, ഇവ നിങ്ങൾക്ക്
സാധുതയുള്ള സാധുവായ
പ്രവർത്തനങ്ങളാണ്,
അതാണ് ക്ലാസ്സിന്റെ
(class) ആശയം .
ഇവിടെ നിങ്ങൾ x നോക്കുകയാണെങ്കിൽ,
x യഥാർത്ഥത്തിൽ ഒരു
ഒബ്ജക്റ്റ് (object) ആണ്.
ഒരു ഒബ്ജക്റ്റ് (object)
എന്നാൽ ഞങ്ങൾ അർത്ഥമാക്കുന്നത്,
പൂർണ്ണസംഖ്യ എന്ന്
പറയുന്നത് പോലെ അബ്‌സ്ട്രാക്ട്
(abstract) അല്ല. ഞാൻ int എന്ന്
പറയുമ്പോൾ, int പൂർണ്ണസംഖ്യകളുള്ള
പ്രവർത്തനങ്ങൾ മാത്രമാണ്
ഞാൻ വിവരിക്കുന്നത്.
ഞാൻ int x എന്ന് പറയുമ്പോൾ

Malayalam: 
മാത്രമേ അതിന് ഒരു
സ്ഥലം അനുവദിക്കൂ,
ഈ സ്ഥാനത്ത്, വിവിധ
പ്രവർത്തനങ്ങൾ ചെയ്യാൻ
കഴിയും. പ്രവർത്തനങ്ങൾ
എന്തായാലും, ഏത്
ഓപ്പറേഷനുകൾ (operation)
അനുവദനീയമാണെങ്കിലും,
പൂർണ്ണസംഖ്യകളിൽ
അനുവദനീയമായ പ്രവർത്തനങ്ങൾ
മാത്രമാണ്. x എന്നത്
പൂർണ്ണസംഖ്യയുടെ
ഒബ്ജക്റ്റാണ് (object).
ക്ലാസ് (class) നാമം int
ഉം ഒബ്ജക്റ്റ് (object)
നാമം x ഉം ആണ്. എനിക്ക്
ഒരേ തരത്തിലുള്ള
കൂടുതൽ വസ്തുക്കൾ
ഉണ്ടായിരിക്കാൻ
കഴിയും. ഉദാഹരണത്തിന്,
ഞാൻ int y എന്ന് പറയുമ്പോൾ,
y എന്നത് ഒരേ തരത്തിലുള്ള
പൂർണ്ണസംഖ്യയുടെ
മറ്റൊരു ഒബ്‌ജക്റ്റാണ്
(object). ചില തലങ്ങളിൽ
നിങ്ങൾക്ക് ക്ലാസുകളെക്കുറിച്ചും
(class) യഥാർത്ഥ വേരിയബിളുകളെ
(variable) ഒബ്ജക്റ്റുകളായും
(object) ചിന്തിക്കാം.
ഇവിടെ y എന്നത് ഡാറ്റാ
(data) തരം സംഖ്യയുടെ
മറ്റൊരു ഒബ്ജക്റ്റാണ്.
അടിസ്ഥാന ഡാറ്റാ
(data) തരങ്ങൾക്ക് ഇതെല്ലാം
ശരിയാണ്. അടിസ്ഥാന
ഡാറ്റാ (data) തരങ്ങൾക്ക്,
ക്ലാസുകൾ (class) ആവശ്യമില്ല.
കൂടാതെ ഈ വ്യത്യാസം
ശരിക്കും ആവശ്യമില്ല,
കാരണം ഭാഷ തന്നെ
നിങ്ങൾക്ക് എല്ലാം
നൽകുന്നു. നിങ്ങൾ
പൂർണ്ണസംഖ്യകളിൽ
ചെയ്യുന്ന പ്രവർത്തനങ്ങളെക്കുറിച്ചുള്ള
ആശയം ഇതിനകം തന്നെ
ഭാഷയും നൽകിയിട്ടുണ്ട്,

English: 
Only when I say int x, we get a location allocated
to it and on this location, we can do various
operations.
So, the operations of ah.. whatever on x,
whatever operations are allowed, are only
those operations that are allowed on integers.
So, x is an object of the type integer.
So, the class name is int and the object name
is x.
I can have more objects of the same type.
So, for example, when I say int y, y is another
object of the same type integer.
So, at some level you can think of types as
classes and actual variables are objects.
So, here y is another object of the data type
integer.
So, this is all ok for basic data types.
So, for basic data types, you really don't
need classes ah.. and objects this distinction
is not really necessary because the language
itself gives you all of that.

Hindi: 
और पूर्णांक के कुछ
गुण हैं।
इसलिए, उदाहरण के
लिए, पूर्णांकों
में केवल 1, 2, 3, 0, -1, -2,
-3 और जैसे मान हो सकते
हैं।
आपके पास मान्य मान
1.6 नहीं हो सकता है,
ठीक है।
इसलिए, हम इंट के बारे
में इनमें से कुछ
गुणों को जानते हैं।
इसलिए, किसी भी समय
जब आपके पास कुछ होता
है जिसे एक क्लास(class)
कहा जाता है, तो आप
जानते हैं कि कुछ
प्रकार हैं।
तो, एक क्लास(class) के
कुछ गुण हैं और केवल
कुछ ऑपरेशन हैं जो
आप डेटा प्रकार पर
कर सकते हैं।
तो, बुनियादी डेटा
प्रकारों के लिए,
भाषा ही आपको बताती
है कि ये उन मूल्यों
का मूल समूह हैं, जिन्हें
आप ले सकते हैं, और
ये वैध संचालन हैं
जो आप कर सकते हैं,
ठीक है।

Hindi: 
तो, हमारी क्लास(class)
की ऊपर धारणा येही
है ..
यहाँ यदि आप x को देखते
हैं, तो x वास्तव में
एक ऑब्जेक्ट(object) है,
सही है।
इसलिए, जब हम किसी
ऑब्जेक्ट(object) से मतलब
रखते हैं, तो उसका
कुछ सार नहीं जब मैं
पूर्णांक कहता हूं,
ठीक है।
जब मैं int कहता हूं,
तो मैं केवल उन गुणों
का वर्णन कर रहा हूं
जो पूर्णांक में
हैं और उसके संचालन
को।
केवल जब मैं int x कहता
हूं, तो हमें एक स्थान
आवंटित किया जाता
है और इस स्थान पर,
हम विभिन्न ऑपरेशन
कर सकते हैं।
तो, आह के संचालन .. जो
कुछ भी एक्स पर, जो
भी संचालन की अनुमति
है, वे केवल वे ऑपरेशन

English: 
So, ah.. the notion of operations that you
do on integers and so, on also is already
given by the language, whereas, if you have
a user defined data type, then it becomes
useful and necessary to define, what is allowed
and what is not allowed, and to define what
operations can be done.
So, lets look at the basic idea of classes.
A class is actually a user defined data type
that specifies how objects of its type can
be created and used, how do you create an
object of a certain class, and how to use
it is described in the class.
So, it directly represents some kind of a
concept in a program.
So, whenever you think of ah.. it.
So, its ah.. so this notion of a it as an
entity, it is plausible that it is a class
or its an object.
So, lets see things like this.
So, I have the notion of a vector, a matrix,
a string and so, on.

Malayalam: 
അതേസമയം, നിങ്ങൾക്ക്
ഒരു ഉപയോക്താവ് നിർവചിച്ച
ഡാറ്റ (data) തരം ഉണ്ടെങ്കിൽ,
അത് നിർവചിക്കാൻ
ഉപയോഗപ്രദവും ആവശ്യവുമാണ്,
എന്താണ് അനുവദനീയമായത്
അനുവദനീയമല്ലാത്തത്,
എന്ത് പ്രവർത്തനങ്ങൾ
ചെയ്യാമെന്ന് നിർവചിക്കുക.
ക്ലാസുകളുടെ (class)
അടിസ്ഥാന ആശയം നോക്കാം.
ഒരു ക്ലാസ് (class) യഥാർത്ഥത്തിൽ
ഒരു ഉപയോക്താവ് നിർവചിച്ച
ഡാറ്റ (data) തരമാണ്,
അത് അതിന്റെ തരത്തിലുള്ള
ഒബ്‌ജക്റ്റുകൾ (object)
എങ്ങനെ സൃഷ്ടിക്കാമെന്നും
ഉപയോഗിക്കാമെന്നും
വ്യക്തമാക്കുന്നു,
ഒരു പ്രത്യേക ക്ലാസിലെ
(class) ഒബ്‌ജക്റ്റ്
(object) നിങ്ങൾ എങ്ങനെ
സൃഷ്ടിക്കും, അത്
എങ്ങനെ ഉപയോഗിക്കാമെന്ന്
ക്ലാസിൽ (class) വിവരിച്ചിരിക്കുന്നു.
ഇത് ഒരു പ്രോഗ്രാമിലെ
(program) ഏതെങ്കിലും തരത്തിലുള്ള
ആശയത്തെ നേരിട്ട്
പ്രതിനിധീകരിക്കുന്നു.
ഒബ്ജക്റ്റ് (object) ഒരു
എന്റിറ്റിയാണ് (entity).
എനിക്ക് ഒരു വെക്റ്റർ
(vector), ഒരു മാട്രിക്സ്
(matrix), ഒരു സ്ട്രിംഗ്
(string) തുടങ്ങിയവ ഉണ്ട്.
ഇവ മിക്കവാറും ക്ലാസുകളാണ്
(class), അതേസമയം, എന്റെ
എല്ലാ വിദ്യാർത്ഥികളും
അടങ്ങുന്ന ഒരു മാട്രിക്സ്
(matrix) എനിക്കുണ്ട്.
പേരും അവരുടെ മാർക്ക്

Malayalam: 
രേഖപ്പെടുത്തുന്നു.
ഒരു നിർദ്ദിഷ്ട ഒബ്‌ജക്റ്റ്
(object). എനിക്ക് ഈ പൂർണ്ണസംഖ്യകളെല്ലാം
ഉൾക്കൊള്ളുന്ന ഒരു
മാട്രിക്സ് (matrix) ഉണ്ടായിരിക്കാം,
കൂടാതെ പൂർണ്ണസംഖ്യകളുടെ
ഗുണനം ചെയ്യാൻ ഞാൻ
ആഗ്രഹിക്കുന്നു.
അതും ഒരു മാട്രിക്സ്
(matrix) ആണ്, ഒബ്ജക്റ്റുകൾ
(object) പ്രത്യേക ക്ലാസ്
(class) വാഗ്ദാനം ചെയ്യുന്നു.
ഇത് ഒരു എന്റിറ്റിയാണ്
(entity) അല്ലെങ്കിൽ ഒരു
അബ്‌സ്ട്രാക്ട്
(abstract) സങ്കൽപ്പമാണ്,
ക്ലാസുകൾ (class) നിർവചിക്കാനുള്ള
ഈ അടിസ്ഥാന ആശയം
സി പ്ലസ് പ്ലസ് (C++)
നൽകുന്നു. അടിസ്ഥാന
ഡാറ്റാ (data) ഘടന എന്താണെന്നോ
ഡാറ്റാ (data) തരം എന്താണെന്നോ
നിങ്ങൾക്ക് നിർവചിക്കാൻ
കഴിയും, കൂടാതെ നിങ്ങൾക്ക്
ആ പ്രത്യേക ഡാറ്റാ
(data) തരത്തിന്റെ ഉദാഹരണങ്ങളും
ക്ലാസുകൾ (class) ഏതെങ്കിലും
വലിയ തോതിലുള്ള പ്രോഗ്രാം
(program) നിർമ്മിക്കുന്നതിനുള്ള
അടിസ്ഥാന ബിൽഡിംഗ്
ബ്ലോക്കായി (building block)
മാറുന്നു. ഇവിടെ
ഒരു ചെറിയ ഉദാഹരണം
എടുക്കാം.
ഞങ്ങൾക്ക് ക്ലാസ്
(class) ഉണ്ട്, അതിനുശേഷം
ഇടത്, വലത് ബ്രേസുകളും
(brace) ഒരു അർദ്ധവിരാമവും

Hindi: 
हैं जो पूर्णांक
पर अनुमत हैं।
तो, x प्रकार पूर्णांक
का एक ऑब्जेक्ट(object)
है।
तो, क्लास(class) का नाम
int है और ऑब्जेक्ट(object)
का नाम x है।
मेरे पास एक ही प्रकार
की और ऑब्जेक्टस(objects)
हो सकती हैं।
इसलिए, उदाहरण के
लिए, जब मैं int y कहता
हूं, तो y एक ही प्रकार
का पूर्णांक होता
है।
तो, कुछ स्तर पर आप
प्रकारों के बारे
में सोच सकते हैं
क्योंकि क्लाससेस(classes)
और वास्तविक वारियाब्लेस
ऑब्जेक्टस(objects) हैं।
तो, यहाँ y डेटा प्रकार
पूर्णांक का एक और
ऑब्जेक्ट(object) है।
इसलिए, बुनियादी
डेटा प्रकारों के
लिए यह सब ठीक है।
इसलिए, बुनियादी
डेटा प्रकारों के
लिए, आपको वास्तव
में क्लाससेस(classes)
की आवश्यकता नहीं
है .. और ऑब्जेक्टस(objects)

English: 
So, these are probably classes, whereas, I
have a matrix which contains all my students’
ah.. names and lets say records their marks
and so, on.
Then, thats a specific object.
I may have a matrix which contains all these
integers and I want to do multiplication of
integers and so, on.
thats also a matrix, but its a matrix of integers.
So, the objects are ah.. offers particular
class.
So, it is a physical entity or it is a abstract
notion, and C plus plus gives you this basic
notion of defining classes.
You can define what the basic ah.. data structure
is or the data type is, and you can also have
instances of that particular data type and
classes form the basic building block for
building any large scale program.
So, lets take a small example here.

Malayalam: 
ഉണ്ട്, ഇതിനുള്ളിൽ
ഞങ്ങൾ ഡാറ്റ മെമ്പറുകളെയും
(data member) ഫംഗ്ഷൻ മെമ്പറുകളെയും
(function member) ഉൾപ്പെടുത്താൻ
പോകുന്നു. ഡാറ്റ
മെമ്പറുകൾ (data member)
വിവരങ്ങൾ സംഭരിക്കേണ്ടതാണ്,
കൂടാതെ ഫംഗ്ഷൻ മെമ്പറുകൾ
(function member) ഡാറ്റ മെമ്പറുകളെ
(data member) എങ്ങനെ കൈകാര്യം
ചെയ്യണമെന്ന് നിങ്ങളോട്
പറയും, ഇത് സ്ട്രക്ച്ചറിൽ
(structure) ചെയ്തതിനു സമാനമാണ്.
അവിടെ സ്ട്രക്റ്റ്
ടൈപ്പ് എക്സ് (struct
type X) എന്നും ബ്രേസുകളും
(brace) ഉണ്ടായിരുന്നു,
ഒപ്പം അംഗങ്ങളുണ്ടായിരുന്നു.
ഇവിടെ ഡാറ്റാ മെമ്പറുകൾ
(data member) മാത്രമല്ല,
ഞങ്ങൾക്ക് ഫംഗ്ഷൻ
മെമ്പറുകളും (function
member) ഉണ്ട് എന്നതാണ്
വ്യത്യാസം. ഒരു ചെറിയ
ഉദാഹരണം കാണാം, ക്ലാസ്
X നു int m ഉണ്ട്, അത്
ഒരു ഡാറ്റ (data) അംഗവും
int mf(int v) ഉണ്ട്. ഇത് ഒരു
ഫംഗ്ഷന്‍ (function) ആണ്.
ഈ ഫംഗ്ഷൻ mf ഒരു പൂർണ്ണസംഖ്യ
v എടുക്കേണ്ടതാണ്,
അത് v യുടെ മൂല്യം

English: 
We have class X followed by left and right
flower braces and a semicolon, and we are
going to put in data mumb members and function
members inside this.
So, the data members are supposed to store
the information and the function members are
supposed to tell you how to manipulate the
data members, right.
So, this ah.. resembles how you did it for
structures.
So, there also we had something called struct
type X and followed by braces, and we had
members inside.
Only difference is that we not only have data
members here, we also have function members.
So, lets see a small example here, Class X
and class X has int m which is a data member
and int mf of int v which is a function or
a method.
So, we have a basic data type inside it and
we have a method inside it.
So, thats a class.
So, X has ah..

Hindi: 
को यह अंतर वास्तव
में आवश्यक नहीं
है क्योंकि भाषा
ही आपको वह सब देती
है।
तो, आह .. आप पर पूर्णांकों
और उसके ऊपर भी किए
जाने वाले ऑपरेशनों
की धारणा, पहले से
ही भाषा द्वारा दी
गई है, जबकि, यदि आपके
पास उपयोगकर्ता परिभाषित
डेटा प्रकार है, तो
यह उपयोगी और परिभाषित
करने के लिए आवश्यक
हो जाता है, क्या अनुमति
है और क्या अनुमति
नहीं है, और क्या संचालन
किया जा सकता है परिभाषित
करने के लिए।
तो, क्लाससेस(classes)
के मूल विचार को देखने
देता है।
एक क्लास(class) वास्तव
में एक उपयोगकर्ता
परिभाषित डेटा प्रकार
है जो निर्दिष्ट
करता है कि इसके प्रकार
की वस्तुओं को कैसे

Malayalam: 
എടുക്കുകയും m ൽ ഇടുകയും
ചെയ്യുന്നു, എന്നാൽ
ഫംഗ്ഷൻ (function) വിളിക്കുന്നതിന്
മുമ്പ് ഉണ്ടായിരുന്ന
പഴയ മൂല്യം തിരികെ
നൽകേണ്ടതാണ്. അത്
ഫംഗ്ഷന്റെ (function) അംഗമാണ്.
ഇത് ഗെറ്റ് (get), സെറ്റ്
(set) ആണ്.
സംഭരിച്ചിരിക്കുന്ന
മുമ്പത്തെ മൂല്യം
നിങ്ങൾക്ക് ലഭിക്കുന്നു,
പക്ഷേ നിങ്ങൾ വിതരണം
ചെയ്യുന്ന പുതിയ
മൂല്യത്തിലേക്ക്
ഇത് സജ്ജമാക്കുകയാണ്.
നിങ്ങൾ വിതരണം ചെയ്യുന്ന
പുതിയ മൂല്യമാണ്
v, കൂടാതെ m ന്റെ പഴയ
മൂല്യം വീണ്ടെടുക്കേണ്ടതുണ്ട്.
ഈ ക്ലാസ് (class) എങ്ങനെ
ഉപയോഗിക്കാമെന്ന്
നോക്കാം. ഞങ്ങൾക്ക്
X var ഉണ്ട്. എക്സ് ഒരു
ഡാറ്റ തരമാണെന്ന്
ഓർമ്മിക്കുക. സ്ട്രക്ച്ചർ
ഉപയോഗിക്കുമ്പോൾ
സ്ട്രക്റ്റ് എക്സ്
(struct X) എന്ന് പറഞ്ഞു.
ക്ലാസുകൾക്കായി
(class) സി പ്ലസ് പ്ലസിൽ
(C++) അത് ചെയ്യേണ്ടതില്ല.
X var. var എന്നത് X എന്ന
ക്ലാസ്സിന്റെ ഒബ്ജക്റ്റാണ്.

English: 
X is a class and it has a variable m or the
member m and it has a function mf.
So, this function mf is supposed to take an
integer v, and it takes the value of v, puts
it in m, but the old value that was there
before the function is called is supposed
to be returned.
So, thats the function's member.
So, the this is something called get and set.
So, you are getting the previous value which
is stored, but you are also setting it to
the new value that you supply.
So, v is the new value that you supply, and
the old value of m is supposed to be retrieved.
So, lets say that is the class description.
We will get to this notion of public in a
little while.
So, lets see how this class can be used.
We have X var.
So, remember X is a data type.
So, instead of class X var which we did for
structures, right wherever we had structures,

Hindi: 
बनाया और उपयोग किया
जा सकता है, आप एक
निश्चित क्लास(class)
की वस्तु कैसे बनाते
हैं, और इसका उपयोग
कैसे करें यह कक्षा
में वर्णित है।
तो, यह सीधे एक कार्यक्रम
में किसी तरह की अवधारणा
का प्रतिनिधित्व
करता है।
इसलिए, जब भी आप इसके
के बारे में सोचते
हैं।
तो, इसकी आह .. तो यह
एक इकाई के रूप में
यह धारणा है, यह प्रशंसनीय
है कि यह एक क्लास(class)
या एक ऑब्जेक्ट(object)
है।
तो, इस तरह से चीजों
को देखने देता है।
तो, मेरे पास एक वेक्टर,
एक मैट्रिक्स, एक
स्ट्रिंग और इसी
तरह की धारणा है।
तो, ये संभवतया क्लाससेस(classes)
हैं, जबकि, मेरे पास
एक मैट्रिक्स है
जिसमें मेरे सभी
छात्रों के नाम हैं
.. और उनके मार्क्स

Hindi: 
को रिकॉर्ड करने
की अनुमति देते हैं।
फिर, एक विशिष्ट ऑब्जेक्ट(object)
है।
मेरे पास एक मैट्रिक्स
हो सकता है जिसमें
ये सभी पूर्णांक
शामिल हैं और मैं
पूर्णांकों का गुणा
करना चाहता हूं और
इसी तरह, पर।
एक मैट्रिक्स भी
है, लेकिन इसके पूर्णांक
का एक मैट्रिक्स।
तो, ऑब्जेक्ट(object) आह
हैं .. विशेष क्लास(class)
प्रदान करता है।
तो, यह एक भौतिक इकाई
है या यह एक अमूर्त
धारणा है, और सी प्लस
प्लस आपको कक्षाओं
को परिभाषित करने
की यह मूल धारणा प्रदान
करता है।
आप परिभाषित कर सकते
हैं कि बुनियादी
आह .. डेटा स्ट्रक्चर(structure)
क्या है या डेटा प्रकार
है, और आपके पास उस
विशेष डेटा प्रकार

Malayalam: 
ഇപ്പോൾ, നിങ്ങൾക്ക്
മെമ്പർ (member) m ആക്സസ്
(access) ചെയ്യണമെങ്കിൽ,
നമുക്ക് var.m എന്ന്
പറയാൻ കഴിയും. ഇത്
സ്ട്രക്ച്ചർ (structure)
പോലെയാണ്, Var.m 7 എന്നത്
ഡാറ്റാ (data) അംഗത്തെ
7 ആയി മാറ്റും. നമുക്ക്
var. mf =9 ചെയ്യാൻ കഴിയും,
ഇത് എന്തുചെയ്യും,
അത് മൂല്യം 9 എടുത്ത്
ഈ ക്ലാസിന് (class) വിതരണം
ചെയ്യും. നിങ്ങളുടെ
മുൻ മൂല്യം 7 ആണെങ്കിൽ,
നിങ്ങൾക്ക് ഈ x മൂല്യം
7 ആയി ലഭിക്കും, എന്നാൽ
നിങ്ങൾ ഇത് 9 ആയി സജ്ജമാക്കുക.
ഇവിടെ നിങ്ങൾ ഈ വരിക്ക്
ശേഷം var.m പ്രിന്റു
(print) ചെയ്യുകയാണെങ്കിൽ,
മൂല്യം 9 ആയിരിക്കും.
അടിസ്ഥാനപരമായി
ക്ലാസിന്റെ (class) നല്ല
കാര്യം, .m ഉപയോഗിച്ച്
അംഗങ്ങളെ ആക്സസ്
(access) ചെയ്തിട്ടുണ്ട്
എന്നതാണ്; ഡോട്ട്
ഓപ്പറേറ്റർ (dot operator)
ഉപയോഗിച്ച് മെത്തേഡുകളും

English: 
we said struct X and so, on.
For classes you don't have to do that in C
plus plus.
X var.
So, var is an object of the type X or the
class X.
Now, if you want to access the member m in
it, we can say var dot m.
So, this is just like the structure, right.
We saw this before, right.
Var dot m is 7 will change the data member
to 7.
Interestingly you can do something like this.
We can do var dot mf of 9, right.
What this will do is, it will take the value
9 and supply that to this class.
So, if the previous value that you contain
is 7, you will get this small case x to be
the value 7, but you set it to 9.

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

Malayalam: 
(method) ഡാറ്റ (data) അംഗങ്ങളും
ആക്സസ് ചെയ്യുന്നു.
പബ്ലിക്, പ്രൈവറ്റ്
(public, private) എന്താണെന്ന്
നോക്കാം. സി പ്ലസ്
പ്ലസിൽ (C++) പബ്ലിക്
(public) അല്ലെങ്കിൽ പ്രൈവറ്റ്
(private) എന്ന രണ്ട് തരത്തിലുള്ള
അംഗങ്ങളും പ്രവർത്തനങ്ങളും
ഉണ്ടായിരിക്കാം.
പബ്ലിക് (public) ആണെങ്കിൽ
ഈ അംഗങ്ങളെ പുറത്തുള്ള
ആർക്കും അക്സസ്സ്
(access) ചെയ്യാൻ കഴിയും,
അതേസമയം പ്രൈവറ്റ്
(private) ആണെങ്കിൽ ക്ലാസിന്റെ
(class) മെത്തേഡുകൾക്ക്
(method) മാത്രമേ ഇത് ആക്സസ്
(access) ചെയ്യാൻ കഴിയൂ.
ഒരു ഫംഗ്ഷൻ (function) പ്രൈവറ്റ്
(private) ആണെങ്കിൽ ഈ ഫംഗ്ഷനെ
(function) പുറത്തു നിന്ന്
വിളിക്കാൻ കഴിയില്ല.
പ്രൈവറ് (private) അംഗങ്ങളുടെ
ഇമ്പ്ലിമെന്റേഷൻ
(implementation) വിശദാംശങ്ങൾ
പുറം ലോകത്ത് നിന്ന്
മറഞ്ഞിരിക്കേണ്ടതാണ്,
പബ്ലിക് മെത്തേഡുകളും
(public methods) മെമ്പറുകളും
(member) പുറം ലോകത്തിൽ
നിന്ന് നേരിട്ട്
ആക്സസ് (access) ചെയ്യാവുന്നതാണ്.
കുറച്ച് സമയത്തിനുള്ളിൽ
ഉദാഹരണങ്ങൾ കാണും.

English: 
So, here if you go and print var dot m after
this line, this would have the value 9 right.
So, basically the nice thing about this class
is that we have the members accessed with
dot m; the methods are also accessed with
dot.
So, both the methods and the data members
are accessed using dot operator.
So, now lets go and look at what is this notion
of public versus private.
So, again if you are exposed to C plus plus,
you probably know this already, but in C plus
plus you can have members and functions that
are of two types, public or private right.
So, if its public, these members can be accessed
by anyone outside whereas, if its private,
then both.
If a member is private, only ah.. the class’s
methods can access it.
If a function is private, right, only ah..
this function cannot be called from outside.

Hindi: 
टाइप एक्स कहा जाता
है और उसके बाद ब्रेसिज़,
और हमारे अंदर सदस्य
होते हैं।
केवल अंतर यह है कि
हमारे यहाँ केवल
डेटा सदस्य नहीं
हैं, हमारे पास फ़ंक्शन
सदस्य भी हैं।
तो, यहाँ एक छोटा सा
उदाहरण देखने को
मिलता है, क्लास(class)
X और क्लास(class) X में
int m है जो एक डेटा सदस्य
है और int v का int mf जो एक
फ़ंक्शन या एक विधि
है।
तो, हमारे पास इसके
अंदर एक बुनियादी
डेटा प्रकार है और
हमारे पास इसके अंदर
एक विधि है।
तो, एक क्लास(class) है।
तो, X में आह है .. X एक
क्लास(class) है और इसमें
एक चर m या सदस्य m है
और इसमें एक फ़ंक्शन
mf है।
तो, यह फंक्शन mf एक
पूर्णांक v लेने वाला

English: 
So, private members are supposed to have implementation
details that are hidden from the outside world,
and public methods and members are directly
accessible from the outside world.
We will see ah.. specific examples in a little
while.
So, what is the difference between struct
and a class?
So, lets see class X. Lets say I put int mf.
By default all members are private in a class.
So, if I did something like this class X int
mf, it means that mf is a method that you
cannot call from outside.
So, lets say I did class X, object x and y
is x dot mf.
This would be invalid because mf is a private
method.
It cannot be called from the external world,
whereas, if this had been a structure, right

Malayalam: 
അപ്പോൾ, സ്ട്രക്റ്റും
(struct) ക്ലാസും (class) തമ്മിലുള്ള
വ്യത്യാസം എന്താണ്?
ക്ലാസ് (class) X നോക്കാം.
ഞാൻ int mf ഇടുന്നുവെന്ന്
പറയാം. ഡിഫോൾട്ട്
(default) ആയി എല്ലാ അംഗങ്ങളും
ഒരു ക്ലാസിൽ (class) പ്രൈവറ്റ്
(private) ആണ്. int mf എന്ന്
കൊടുത്താൽ അതിനർത്ഥം
നിങ്ങൾക്ക് പുറത്തു
നിന്ന് വിളിക്കാൻ
കഴിയാത്ത ഒരു മെത്തേഡ്
(method) ആണ് mf എന്നാണ്.
ഒബ്ജക്റ്റ് (object) x
ഉം y x.dot mf ആണ്. Mf ഒരു
പ്രൈവറ്റ് മെത്തേഡ്
(private method) ആയതിനാൽ ഇത്
അസാധുവാണ്. ബാഹ്യ
ലോകത്തിൽ നിന്ന്
ഇതിനെ വിളിക്കാൻ
കഴിയില്ല, അതേസമയം,
ഇത് ഒരു സ്ട്രക്ച്ചർ
(structure) ആയിരുന്നെങ്കിൽ
struct X int m, നമ്മുടെ ക്ലാസ്
(class) x ന് തുല്യമാണ്,
m ഒരു പബ്ലിക് വേരിയബിളാണ്
(public variable). സ്ട്രക്ച്ചറുകൾ
(structure) പ്രാഥമികമായി
ഡാറ്റ (data) ഘടനകൾക്കായി
ഉപയോഗിക്കുന്നു,
അംഗങ്ങൾക്ക് എന്തെങ്കിലും
മൂല്യമെടുക്കാൻ
കഴിയുമെങ്കിലും,
പ്രോഗ്രാമറിൽ (programmer)
നിന്ന് എന്തെങ്കിലും

Hindi: 
है, और यह v का मान लेता
है, इसे m में रखता
है, लेकिन फंक्शन
के आने से पहले जो
पुराना मूल्य था,
उसे वापस करना चाहिए।
तो, वे फ़ंक्शन के
सदस्य है । तो, यह
कुछ ऐसा है जिसे गेट
और सेट कहा जाता है।
तो, आपको पिछला मान
मिल रहा है जो संग्रहीत
है, लेकिन आप इसे नए
मूल्य पर भी सेट कर
रहे हैं जो आप आपूर्ति
करते हैं।
तो, v नया मूल्य है
जिसे आप आपूर्ति
करते हैं, और m के पुराने
मूल्य को पुनर्प्राप्त
किया जाना चाहिए।
तो, हम कहते हैं कि
क्लास(class) विवरण है।
हम थोड़ी देर में
जनता की इस धारणा
को प्राप्त करेंगे।
तो, चलो देखते हैं
कि इस क्लास(class) का
उपयोग कैसे किया
जा सकता है।
हमारे पास एक्स संस्करण
है।

English: 
struct X int m, by default that means, its
actually equivalent to our class x with m
being a public variable and structs are primarily
used for data structures, where the members
can take any value whereas, you use classes
whenever you want something hidden from the
programmer.
So, the programmer should get clean interfaces
like insert, delete and so, on, and whatever
manipulation is happening internally need
not be exposed to the programmer.
So, Lets see a small example which explain
this in a little more detail.
Lets say I have a struct called Date which
has year, month and day and I have Date my_birthday.
So, lets say its tracking a birthday.
If you do this, there is nothing which will
stop you from writing something like this.
my_birthday dot y is 12, my_birthday dot m
is 30, my_birthday dot d is 19 1950.

Malayalam: 
മറച്ചുവെക്കാൻ നിങ്ങൾ
ആഗ്രഹിക്കുമ്പോഴെല്ലാം
നിങ്ങൾ ക്ലാസുകൾ
(class) ഉപയോഗിക്കുന്നു.
പ്രോഗ്രാമർ‌ക്ക്
(programmer) ഇൻസേർട്ട് (insert),
ഡിലീറ്റ് (delete) മുതലായ
ക്ലീൻ‌ ഇന്റർ‌ഫേസുകൾ‌
(clean interface) ലഭിക്കണം,
കൂടാതെ ആന്തരികമായി
സംഭവിക്കുന്നതെന്തും
പ്രോഗ്രാമർ‌ക്ക്
(programmer) വെളിപ്പെടുത്തേണ്ടതില്ല.
ഇത് കുറച്ചുകൂടി
വിശദമായി വിവരിക്കുന്ന
ഒരു ചെറിയ ഉദാഹരണം
നോക്കാം. എനിക്ക്
തീയതി എന്ന ഒരു സ്ട്രക്റ്റ്
(struct) ഉണ്ടെന്നും അത്
വർഷം, മാസം, ദിവസം
എന്നിവയുണ്ടെന്നും
എനിക്ക് തീയതി എന്റെ_ജന്മദിനം
ഉണ്ടെന്നും പറയാം.
ജന്മദിനം ട്രാക്കു
(track) ചെയ്യുന്നത്
പറയാൻ അനുവദിക്കുക.
നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ,
my_birthday.y(12, 30, 1950). അതിനാൽ,
നിങ്ങൾ വലതുവശത്ത്
നോക്കുകയാണെങ്കിൽ,
അവയെല്ലാം പൂർണ്ണസംഖ്യകളും
ഇടത് ഡാറ്റാ (data) തരങ്ങളെല്ലാം
പൂർണ്ണസംഖ്യകളാണ്.
y, 12, m 30 വരെയും d 1950 വരെയും
സജ്ജമാക്കുന്നു.
അതിന്റെ മൂന്ന് പ്രത്യേക
സംഖ്യകൾ ഉപയോഗിക്കുന്നതുപോലെ,
മൂന്ന് വ്യത്യസ്ത
മൂല്യങ്ങൾ നൽകുക,
ഇത് ഒരു തീയതിയായി
കൈകാര്യം ചെയ്യുകയാണെങ്കിൽ,
ഒരു ചെറിയ പ്രശ്നമുണ്ട്.
നിങ്ങൾ 12-ാം വർഷത്തേക്കാണ്

Hindi: 
तो, याद रखें एक्स
एक डेटा प्रकार है।
इसलिए, क्लास(class) X
के बजाय जो हमने स्तृक्तुरेस(structures)
के लिए किया था, जहां
भी हमारे पास स्तृक्तुरेस(structures)
थीं, हमने कहा कि स्ट्रक्चर(structure)
X और इसी तरह।
क्लास(class) के लिए आपको
सी प्लस प्लस में
ऐसा नहीं करना है।
एक्स संस्करण।
तो, var क्लास(class) X है
या फिर टाइप X का एक
ऑब्जेक्ट है।
अब, यदि आप इसमें सदस्य
m को एक्सेस करना चाहते
हैं, तो हम वर डॉट
म(var dot m) कह सकते हैं।
तो, यह स्ट्रक्चर(structure)
की तरह ही है, सही
है।
हमने इसे पहले देखा
था, ठीक है।

English: 
So, if you look at the right side, they are
all integers and the left side data types
are all integers.
So, you are setting y to 12, m to 30 and d
to 1950.
So, as three its separate integers used, assign
three separate values which is all ok, but
there is a problem.
If we go and deal with this as a date, there
is a small problem.
You are looking at year 12, maybe its 12 AD,
but the month is 30 and the day is 1950.
This doesn't make sense..
So, maybe it was a mistake.
It should have been year 1950 and day must
have been 30 and probably the month must have
been 12, where we are talking about 30th December
1950, right.
So, maybe it was a mistake, but if you have
a structure from the outside, by mistake if
you do this, there is nothing which will stop
you from doing it whereas, if its a class,

Malayalam: 
നോക്കുന്നത്, ഒരുപക്ഷേ
അതിന്റെ എ.ഡി 12 ആയിരിക്കാം,
പക്ഷേ മാസം 30 ഉം ദിവസം
1950 ഉം ആണ്. ഇത് ശരിയല്ല.
ഒരുപക്ഷേ അത് ഒരു
തെറ്റായിരിക്കാം.
അത് 1950 വർഷവും ദിവസം
30 ഉം ആയിരിക്കണം,
മാസം 12 ആയിരിക്കണം,
അവിടെ നമ്മൾ സംസാരിക്കുന്നത്
1950 ഡിസംബർ 30 നെക്കുറിച്ചാണ്,
നിങ്ങൾക്ക് പുറത്തുനിന്നുള്ള
ഒരു ഘടനയുണ്ടെങ്കിൽ,
നിങ്ങൾ ഇത് ചെയ്താൽ
അബദ്ധവശാൽ, ഇത് ചെയ്യുന്നതിൽ
നിന്ന് നിങ്ങളെ തടയുന്ന
ഒന്നും തന്നെയില്ല,
അതേസമയം ഒരു ക്ലാസ്
(class) ആണെങ്കിൽ എനിക്ക്
കുറച്ച് പരിശോധന
നടത്തി പരിരക്ഷിക്കാം
നിന്ന് അസാധുവായ
മൂല്യങ്ങൾ. ദിവസം
ആരംഭിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.
എനിക്ക് Y, M, D എന്നിവ
മൂന്ന് പൂർണ്ണസംഖ്യകളായി
കൈമാറിയിട്ടുണ്ട്,
കൂടാതെ തീയതി ഡാറ്റാ
തരത്തിലേക്കുള്ള
പോയിന്ററായ ഈ dd സജ്ജീകരിക്കാൻ
ഞാൻ ആഗ്രഹിക്കുന്നു.
അതിനാൽ, dd, y, m, d എന്നിവ
കൈമാറുന്ന y, m, d എന്നീ
മൂല്യങ്ങളായിരിക്കണം.
എനിക്ക് ഇതുപോലുള്ള
ഒരു പ്രവർത്തനം ആവശ്യമായിരിക്കാം,
ഈ ഘടനയിലെ അംഗങ്ങളെ
ചില മൂല്യങ്ങളിലേക്ക്

English: 
then I can put some check and protect invalid
values from not being taken.
So, lets look at some other ah.. additional
things, right.
Lets say I want to initialize the day.
I have Y, M and D which are passed as three
integers and I want to set up this DD which
is a pointer to the Date data type.
So, I want dd's, y, m and d to be the values
y, m and d that are passed on.
So, maybe I want a function like this, initialize
the members of this structure to certain values
or I may want to add a certain number of days
to the type.
So, lets say the current date is 30th December
1950, and I want to add 2 days to it and move
to January 1, 1951.
Let’s say I want to do that.
I should be able to do it.

Malayalam: 
സമാരംഭിക്കുക അല്ലെങ്കിൽ
തരത്തിലേക്ക് ഒരു
നിശ്ചിത എണ്ണം ദിവസങ്ങൾ
ചേർക്കാൻ ഞാൻ ആഗ്രഹിച്ചേക്കാം.
നിലവിലെ തീയതി 1950
ഡിസംബർ 30 ആണെന്ന്
പറയട്ടെ, അതിൽ 2 ദിവസം
ചേർത്ത് 1951 ജനുവരി
1 ലേക്ക് മാറാൻ ഞാൻ
ആഗ്രഹിക്കുന്നു.
എനിക്ക് അത് ചെയ്യാൻ
കഴിയണം. കുറച്ച്
ദിവസങ്ങൾ ചേർത്ത്
ഒരു സംവിധാനം നടത്തുക,
ഡിസംബർ 30 മുതൽ 2 ദിവസം
ഡിസംബർ 32 അല്ലെന്ന്
ഞാൻ തിരിച്ചറിയുന്നില്ല.
വാസ്തവത്തിൽ, ഇത്
ഡിസംബറിൽ അല്ല, ജനുവരിയിൽ,
ഈ വർഷം ജനുവരിയിൽ
പോലും ഇല്ല, ഇത് യഥാർത്ഥത്തിൽ
അടുത്ത വർഷത്തിലേക്ക്
മാറുന്നു. 1950 ഡിസംബർ
30 ലേക്ക് ഞാൻ 2 ദിവസം
ചേർത്താൽ, ആന്തരികമായി
ഇത് സ്വപ്രേരിതമായി
1951 ജനുവരി 1 ലേക്ക്
മാറാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.
വാസ്തവത്തിൽ, അധിവർഷം
പോലുള്ള കേസുകൾ (case)
ഉചിതമായി കൈകാര്യം
ചെയ്യാൻ ഞാൻ ആഗ്രഹിച്ചേക്കാം.
ഈ വിശദാംശങ്ങളെല്ലാം
പ്രോഗ്രാമർക്ക്
(programmer) വെളിപ്പെടുത്താൻ
ഞാൻ ആഗ്രഹിക്കുന്നില്ല.
ഇത് വളരെ ബുദ്ധിമുട്ടാണ്.
പ്രോഗ്രാമറിന് (programmer)

Hindi: 
वर डॉट म(var dot m) 7 है,
डेटा मेंबर को 7 में
बदल देगा।
दिलचस्प बात यह है
कि आप ऐसा कुछ कर सकते
हैं।
हम 9 का वर डॉट मफ(var
dot mf) कर सकते हैं, ठीक
है।
यह क्या करता है, यह
मान 9 लेगा और इस क्लास(class)
को आपूर्ति करेगा।
इसलिए, यदि आपके पास
पिछला मान 7 है, तो
आपको यह मान 7 होने
के लिए यह छोटा केस
x मिलेगा, लेकिन आप
इसे 9 पर सेट करते
हैं।
यहां, यदि आप जाते
हैं और इस लाइन के
बाद वर डॉट म(var dot m)
प्रिंट करते हैं,
तो यह होगा मान 9 सही।
तो, मूल रूप से इस
क्लास(class) के बारे

Hindi: 
में अच्छी बात यह
है कि हम सदस्यों
को डॉट एम के साथ एक्सेस
किया गया है; तरीके
डॉट के साथ भी एक्सेस
किए जाते हैं।
तो, दोनों तरीकों
और डेटा सदस्यों
को डॉट ऑपरेटर का
उपयोग करके एक्सेस
किया जाता है।
इसलिए, अब जाकर देखते
हैं कि सार्वजनिक
बनाम निजी की यह धारणा
क्या है।
इसलिए, फिर से यदि
आप सी प्लस प्लस के
संपर्क में हैं, तो
आप शायद यह पहले से
ही जानते हैं, लेकिन
सी प्लस प्लस में
आपके सदस्य और कार्य
दो प्रकार के हो सकते
हैं, सार्वजनिक या
निजी सही।
इसलिए, यदि इसके सार्वजनिक,
इन सदस्यों को बाहर
के किसी भी व्यक्ति
द्वारा पहुँचा जा
सकता है, जबकि यदि
यह निजी है, तो दोनों।
यदि कोई सदस्य निजी
है, केवल आह .. क्लास’स(class’s)

English: 
Add a few days and have a mechanism by which
I not only recognize that 2 days from 30th
December is not 32nd December.
In fact, its not even in December, its in
January and its not even in January of this
year, its actually moving to the next year.
So, if I add 2 days to 30th December, 1950,
internally I want this to automatically move
to January 1st 1951.
In fact, I may want to handle cases like leap
year and so, on also appropriately.
All these details I don't want to expose it
to the programmer.
So, this becomes very cumbersome.
All I want to give to the programmer is add_day
as an interface.
With structures its not easily doable because
you can always come and manipulate these values
without going through these methods.
You may go and improve increment d directly
without realizing that the tuple d, m, y is
not valid.

Malayalam: 
ഞാൻ നൽകാൻ ആഗ്രഹിക്കുന്നത്
ഒരു ഇന്റർഫേസായി
(interface) add_day മാത്രമാണ്.
ഘടനകളിലൂടെ ഇത് എളുപ്പത്തിൽ
ചെയ്യാൻ കഴിയില്ല,
കാരണം നിങ്ങൾക്ക്
എല്ലായ്പ്പോഴും
ഈ രീതികളിലൂടെ കടന്നുപോകാതെ
തന്നെ ഈ മൂല്യങ്ങൾ
കൈകാര്യം ചെയ്യാൻ
കഴിയും. ട്യൂപ്പിൾ
(tuple) d, m, y സാധുതയുള്ളതല്ലെന്ന്
മനസിലാക്കാതെ നിങ്ങൾക്ക്
നേരിട്ട് ഇൻക്രിമെന്റ്
(increemnt) d ചെയ്യാൻ‌ കഴിയും,
പക്ഷേ എല്ലായ്‌പ്പോഴും
ഒരു ഫംഗ്ഷനായി (function)
add_day യിലൂടെ കടന്നുപോകാൻ‌
നിങ്ങൾ‌ നിർബന്ധിതനാണെങ്കിൽ‌,
add_day യെ കൂടുതൽ‌ ക്ലീനർ‌
(cleaner) രീതിയിൽ നടപ്പിലാക്കാനും
എല്ലാ പിശകുകളും
പരിശോധിക്കാനും
പ്രവർ‌ത്തനം നടപ്പിലാക്കാനും
കഴിയും. അത് എല്ലായ്പ്പോഴും
ശരിയാണ്. ഒരു ചെറിയ
ഉദാഹരണം നോക്കാം.
എനിക്ക് int y, m, d ഉണ്ട്.
എനിക്ക് എല്ലായ്പ്പോഴും
തീയതികൾക്ക് ചില
സാധുവായ മൂല്യം വേണം.
ഒരു കൺസ്ട്രക്റ്റർ
(constructor) എന്ന് വിളിക്കുന്നത്
എനിക്ക് വേണം. തീയതി
എന്ന് വിളിക്കുന്ന
ഈ ഒബ്‌ജക്റ്റ് (object)
എപ്പോൾ വേണമെങ്കിലും
സൃഷ്ടിക്കാൻ പോകുമ്പോൾ,
അതിന് സാധുവായ മൂല്യങ്ങൾ
നൽകേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം
അത് തെറ്റായിരിക്കും
കൂടാതെ add_day യെ പിന്തുണയ്ക്കാൻ
ഞാൻ ആഗ്രഹിക്കുന്നു.
ഇത് സ്ട്രക്റ്റ്

Malayalam: 
(struct) തീയതിയിൽ നൽകിയിട്ടുണ്ടെങ്കിലും,
ഇത് സാധുവായ വാക്യഘടനയല്ല.
ഞങ്ങൾക്ക് ഇവിടെ
ക്ലാസ് തീയതി വേണം,
ക്ലാസ് (class) തീയതിക്ക്
മൂന്ന് അംഗങ്ങൾ y,
m, d എന്നിവ ഉണ്ടാകും,
ഇതിന് രണ്ട് മെത്തേഡുകളുണ്ടാകും
(method), അത് മൂന്ന് പ്രാരംഭ
മൂല്യങ്ങളും add_day
കളും എടുക്കുന്ന
തീയതി നിലവിലെ തീയതിയിലേക്കുള്ള
ദിവസങ്ങളുടെ എണ്ണം
ചേർക്കും.
നിങ്ങൾ ഇത് ചെയ്യുന്ന
നിമിഷം, നിങ്ങൾ എന്റെ_ജന്മദിനം
തീയതി ചെയ്യുകയാണെങ്കിൽ,
ഇത് തെറ്റാണ്, കാരണം
ഇത് സമാരംഭിച്ചിട്ടില്ല.
തീയതി എന്റെ_ജന്മദിനം
12, 30, 1950 ചെയ്താൽ, വർഷം
12, മാസം 30, ദിവസം 1950
എന്നിവയാണ്. add_day എഴുതാൻ
കഴിയുന്ന തരത്തിൽ
ഇത് ഒരു പിശകായി
തിരിച്ചറിയാനും
ഇത് സൂചിപ്പിക്കാനും
കഴിയും. എന്നിരുന്നാലും,
നിങ്ങൾ 1950, 12, 30 തീയതി
എന്റെ_ദിവസം ചെയ്താൽ,
ഇത് സാധുവായ ഒരു
ദിവസമായി അംഗീകരിക്കപ്പെടും,
പിന്നീട് ഞാൻ myBirthday.add_day
=2 ചെയ്താൽ, ജന്മദിനം
മാറുന്നു. 1950 ഡിസംബർ
30 1951 ഇൽ നിന്ന് ജനുവരി
1 ആവുന്നു. myBirthday.m അസാധുവാണ്,
കാരണം നിങ്ങൾ അംഗത്തെ
നേരിട്ട് ആക്സസ്
(access) ചെയ്യുന്നു, ഇത്
ശരിയല്ല.

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

English: 
You may do that, but if you are forced to
go through add_day as a function always, then
add_day can be implemented in a much cleaner
way and all the errors can be checked and
the function can be implemented.
So, that its always correct.
So, lets look at this, a small example.
I have int y, m, d.
I always want ah.. some valid value for the
dates.
So, I want what is called a constructor.
So, any time this object called date is going
to be created, it has to be supplied valid
values, otherwise it would be incorrect and
I want to be supporting add day.
So, even though it is given with struct Date,
this is not valid syntax.
So, we would want class Date here, and class
Date will have three members y, m and d and
it will have two methods Date which will take
the three initial values and add_days which

Hindi: 
तो, हम कहते हैं कि
मैंने क्लास(class) X,
ऑब्जेक्ट एक्स और
वाई, एक्स डॉट एमएफ
किया है।
यह अमान्य होगा क्योंकि
mf एक निजी विधि है।
इसे बाहरी दुनिया
से नहीं बुलाया जा
सकता है, जबकि, अगर
यह एक स्ट्रक्चर(structure)
थी, सही स्तृक्त X
int m, डिफ़ॉल्ट रूप
से, इसका मतलब है,
इसका वास्तव में
हमारी क्लास(class) x के
बराबर है जिसमें
m केवल सार्वजनिक
चर है और मुख्य रूप
से डेटा स्तृक्तुरेस(structures)
के लिए उपयोग किया
जाता है , जहां सदस्य
कोई भी मूल्य ले सकते
हैं, जबकि आप जब भी
प्रोग्रामर से कुछ
छिपाते हैं तो आप
क्लाससेस(classes) का उपयोग
करते हैं।
तो, प्रोग्रामर को
सम्मिलित, हटाएं
और इसी तरह स्वच्छ
इंटरफेस मिलना चाहिए,

English: 
will ah.. which will add the ah.. certain
number of days to the current date.
So, the moment you do this, if you do Date
my_birthday, this would be incorrect because
its not initialized.
If you do Date my_birthday of 12, 30, 1950,
the year is 12, the month is 30 and day is
1950.
add_day can be written in such a way that
this can be recognized as an error and this
can be indicated.
However, if you do Date my_day of 1950, 12,
30, this would be ah.. recognized as a valid
day and later if I do my_birthday dot add_day
of 2, the birthday moves from ah.. 30th December
1950 to 1st January 1951.
So, this is ah.. clean.
However, if I do my_birthday dot m is 14,
this would be invalid because you are accessing

Malayalam: 
നിങ്ങൾ ക്ലാസുകൾ
(class) ചെയ്യുകയാണെങ്കിൽ,
അതിനുള്ള മാർഗം നിങ്ങൾക്ക്
y, m, d എന്നിവ പ്രൈവറ്റ്
(private) ആയി ഉണ്ട്, എല്ലാ
മെത്തേഡുകളും പബ്ലിക്
(public) ആയി ഉണ്ട്. തീയതി
എല്ലാവർക്കുമുള്ളതാണ്.
add_day യഥാർത്ഥത്തിൽ
y, y, d എന്നിവയുടെ ഉള്ളടക്കത്തെ
മാറ്റും, ഞങ്ങൾക്ക്
മാസം, ദിവസം, വർഷം
എന്നിങ്ങനെ മൂന്ന്
മെത്തേഡുകളുണ്ട്
(method). ഈ മൂന്ന് മെത്തേഡുകളും
(method) നിലവിലെ മാസം,
നിലവിലെ ദിവസം, നിലവിലെ
വർഷം എന്നിവ നൽകുന്നു.
ഇവ ഡാറ്റയിലേക്ക്
(data) റീഡ് ആക്സസ് (read
access) മാത്രമേ നൽകുന്നുള്ളൂ.
തീയതി റൈറ്റ് ആക്സസ്
(write access) നൽകണം. y, m, d എന്നിവയുടെ
ഉള്ളടക്കങ്ങൾ മാറ്റാനും
add_day ന് y, m, d എന്നിവയുടെ
ഉള്ളടക്കങ്ങൾ മാറ്റാനും
കഴിയും. 1950, 12, 30 തീയതികളിലെ
എന്റെ_ജന്മദിനം ഈ
മൂന്ന് മൂല്യങ്ങളായി
y, m, d എന്നിവ മാറ്റും,

Hindi: 
और जो कुछ भी हेरफेर
हो रहा है, उसे आंतरिक
रूप से प्रोग्रामर
को उजागर करने की
आवश्यकता नहीं है।
तो, चलिए एक छोटा सा
उदाहरण देखते हैं
जो इसे थोड़ा और विस्तार
से बताता है।
आइए कहते हैं कि मेरे
पास डेट नामक एक स्तृक्त(struct)
है जिसमें वर्ष, महीना
और दिन है और मेरे
पास तारीख my_birthday है।
तो, मान लें कि इसके
जन्मदिन को ट्रैक
करना है।
यदि आप ऐसा करते हैं,
तो ऐसा कुछ भी नहीं
है जो आपको ऐसा कुछ
लिखने से रोके।
माइ_बर्थड़े my_birthday डॉट
dot य y 12 है, माइ_बर्थड़े
dot m 30 है, माइ_बर्थड़े
dot d 19 1950 है।
इसलिए, यदि आप दाईं
ओर देखते हैं, तो वे
सभी पूर्णांक हैं
और बाईं ओर डेटा प्रकार

English: 
the member m directly and this is not correct.
So, if you do classes, the way to do that
is you have y, m and d as private and you
have the all the methods as public.
So, Date is public.
add_day will actually change the contents
of y, y and d and we have three methods called
month, day and year and these three methods
actually return the current month, the current
day and current year.
So, these three methods give you only read
access to the data.
Date is supposed to give write access.
You can change the contents of y, m and d
and add_day can also change the contents of
y, m and d.
So, Date my_birthday of 1950, 12, 30 will
change y, m and d to be these three values
and I can do printf percentage d my_birthday
dot month and my_birthday dot month is a method.

Malayalam: 
കൂടാതെ എനിക്ക് printf
%d my_birthday.month ഉം my_birthday ഉണ്ട്.
Mybirthday.month ഒരു മെത്തേഡ്
(method) ആണ്. ആ മെത്തേഡ്
(method) നോക്കുകയാണെങ്കിൽ,
അത് m നൽകുന്നു, m ന്റെ
മൂല്യം എന്താണ്,
അത് 12 ആയിരിക്കണം.
ഇത് ഇവിടെ 12 അച്ചടിക്കും.
എന്നിരുന്നാലും,
mybirthday.month 14 ആണ്; നിങ്ങൾ
കംപൈൽ (compile) ചെയ്യുമ്പോഴും
കംപൈലർ (compiler) അത് കണ്ടു
പിടിക്കും, m ഒരു പ്രൈവറ്റ്
ആട്രിബ്യൂട്ടാണെന്ന്
(private attribute) പറയുകയും
ചെയ്യും. ഇത് നേരിട്ട്
കൈകാര്യം ചെയ്യാൻ
കഴിയില്ല. m കൈകാര്യം
ചെയ്യണമെങ്കിൽ, ഒന്നുകിൽ
ഒരു പുതിയ വേരിയബിൾ
(variable) സൃഷ്ടിച്ച്
അതിലൂടെ ആക്സസ്സ്
(access) ചെയ്യാൻ കഴിയും,
അല്ലെങ്കിൽ അതിലേക്ക്
ദിവസങ്ങൾ മാത്രമേ
ചേർക്കാൻ കഴിയൂ.
ഇത് നേരിട്ട് കൈകാര്യം
ചെയ്യാൻ കഴിയില്ല.
സാധുവായ ഒരു തീയതി
എന്ന ആശയം വളരെ പ്രധാനപ്പെട്ട
ഒരു പ്രത്യേക കേസാണ്,
നിങ്ങൾ ഇത് ചെയ്യാൻ
ആഗ്രഹിക്കുകയും
ഞങ്ങളുടെ ഡാറ്റാ
(data) തരം പരീക്ഷിക്കാൻ
ആഗ്രഹിക്കുകയും
ചെയ്യുന്നു, അടിസ്ഥാന
ഡാറ്റയ്ക്ക് (data) സാധുതയുണ്ടെന്ന്
എല്ലായ്പ്പോഴും
ഉറപ്പുണ്ട്. ഉദാഹരണത്തിന്,

Hindi: 
सभी पूर्णांक हैं।
इसलिए, आप y को 12, m से
30 और d से 1950 तक सेट कर
रहे हैं।
इसलिए, जैसे कि इसके
तीन पूर्णांकों का
उपयोग किया जाता
है, तीन अलग-अलग मान
निर्दिष्ट करें,
जो ठीक है, लेकिन एक
समस्या है।
यदि हम जाते हैं और
एक तारीख के रूप में
इससे निपटते हैं,
तो एक छोटी सी समस्या
है।
आप वर्ष 12 को देख रहे
हैं, शायद ये 12 एडी
को, लेकिन माह ३० है
और दिन 1950 है।
इसका कोई मतलब नहीं
है।
इसलिए, शायद यह एक
गलती थी।
यह वर्ष 1950 होना चाहिए
था और दिन 30 रहा होगा
और शायद महीना 12 रहा
होगा, जहाँ हम 30 दिसंबर

English: 
If we go and look at that method, it returns
m and what is the value of m, its supposed
to be 12.
So, it will print 12 here.
However, if I do my_birthday dot m is 14;
the compiler will catch it even when you compile
it, the compiler will catch it and say that
m is a private attribute.
It cannot be manipulated directly.
So, if you want to manipulate m, you can either,
go and create a new variable and access through
it, or you can only add days to it.
You cannot manipulate it directly.
So, the notion of a valid date is a very important
special case, and you want to do this and
you want to try and design our data type so,
that there is always some guarantee that the
underlying data is valid.
So, for example, may be I want to design a
class that is supposed to represent a point
in the first quadrant, right.

Malayalam: 
ആദ്യത്തെ ക്വാഡ്രന്റിലെ
(quadrant) ഒരു പോയിന്റിനെ
(point) പ്രതിനിധീകരിക്കുന്ന
ഒരു ക്ലാസ് (class) രൂപകൽപ്പന
ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നുണ്ടാകാം.
ആദ്യത്തെ ക്വാഡ്രന്റ്
(quadrant) 0, 0 അല്ലെങ്കിൽ
ഉത്ഭവം ഉൾപ്പെടെയുള്ള
എന്തും ആണ്, ആദ്യത്തെ
ക്വാഡ്രന്റ് (quadrant)
0, 0 ഉൾപ്പെടെയുള്ള
എന്തും ആണ്, ഞാൻ വലത്തേക്ക്
നീങ്ങുകയോ മുകളിലേക്ക്
നീങ്ങുകയോ ചെയ്താൽ,
അത് ഒരു പ്ലെയിനിലെ
(plane) ആദ്യത്തെ ക്വാഡ്രന്റ്
(quadrant) ആയിരിക്കും.
ഒരു ഘട്ടത്തിലും,
ഈ പോയിന്റ് (point) ആദ്യത്തെ
ക്വാഡ്രന്റിൽ (quadrant)
നിന്ന് പുറത്തുകടക്കാൻ
പാടില്ല. പ്രവർത്തനങ്ങൾ
നടത്തുകയും ഡാറ്റ
(data) ഇപ്പോഴും ആദ്യത്തെ
ക്വാഡ്രന്റിൽ (quadrant)
ഉണ്ടോ ഇല്ലയോ എന്ന്
എല്ലായ്പ്പോഴും
പരിശോധിക്കുകയും
ആദ്യത്തെ ക്വാഡ്രന്റിൽ
(quadrant) നിന്ന് പുറത്തുകടക്കുകയാണെങ്കിൽ
ഒരു പിശക് റിപ്പോർട്ട്
(report) ചെയ്യുകയും ചെയ്യും.
സാധുത പരിശോധിക്കുന്നതിന്,
ഇത് എല്ലായ്പ്പോഴും
ഉപയോഗപ്രദമാണ്.
ഈ മുഴുവൻ കാര്യങ്ങളും
എങ്ങനെയായിരിക്കുമെന്ന്
നോക്കാം. തീയതി എന്ന്
വിളിക്കുന്ന ഈ പ്രവർത്തനത്തെക്കുറിച്ച്
ഞാൻ സംസാരിക്കുകയായിരുന്നു.
ഈ തീയതിക്ക് ഒരു
പ്രത്യേക ഫംഗ്ഷൻ
(function) ഉണ്ട്, അത് ക്ലാസിന്റെ

Malayalam: 
(class) പേരിന് സമാനമായ
പേര് വഹിക്കുന്നു.
നീലയും ചുവപ്പും
നിറമുള്ള ഒന്ന് നിങ്ങൾക്ക്
കാണാൻ കഴിയും, അവയ്ക്ക്
ഒരേ പേരുണ്ട്. കൺ‌സ്‌ട്രക്റ്റർ‌
(constructor) എല്ലായ്‌പ്പോഴും
ക്ലാസിന് (class) സമാനമായ
പേരാണ് സ്വീകരിക്കുന്നത്.
ഈ സാഹചര്യത്തിൽ,
yy, mm, dd എന്നീ മൂന്ന്
സംഖ്യകൾ എടുക്കുന്ന
രീതിയാണ് കൺ‌സ്‌ട്രക്റ്റർ‌
(constructor), അത് എന്താണ്
ചെയ്യുന്നത്, ഇത്
ലോക്കൽ‌ വേരിയബിൾ‌
(local variable) y യെ yy ലേക്ക്
നിർ‌ണ്ണയിക്കുന്നു,
കൂടാതെ ലോക്കൽ‌ വേരിയബിൾ‌
(local variable) m ന് മൂല്യം
mm ഉം ലോക്കൽ‌ വേരിയബിൾ‌
(local variable) d നിർ‌ണ്ണയിക്കുന്നു
മൂല്യം dd. തീയതി എന്ന
തരം ഒബ്ജക്റ്റ് (object)
സൃഷ്ടിക്കുകയും
തീയതി 12, 30, 1950 ഇടുകയും
ചെയ്താൽ, ആന്തരികമായി
നിങ്ങൾക്ക് കൺ‌സ്‌ട്രക്റ്ററിനുള്ളിൽ
(constructor) കോഡ് എഴുതാൻ
കഴിയും, അത് പരിശോധിച്ച്
സാധുവാണ്, ശരിയാണെന്ന്
പറയുക. ഇത് സാധുതയുള്ളതാണെങ്കിൽ,
അത് സമാരംഭിക്കുന്നു,
കൂടാതെ കോഡിനുള്ളിൽ
(code) നിങ്ങൾ ചെയ്യുന്ന
ഈ പരിശോധന അതേപടി
ഉപേക്ഷിച്ചേക്കാം.
ഞാൻ നിർവചിക്കുന്നത്
അവസാനിപ്പിക്കുകയാണെങ്കിൽ,

Hindi: 
1950 की बात कर रहे हैं,
ठीक है।
तो, शायद यह एक गलती
थी, लेकिन अगर आपके
पास बाहर से एक स्ट्रक्चर(structure)
है, तो गलती से अगर
आप ऐसा करते हैं, तो
ऐसा कुछ भी नहीं है
जो आपको ऐसा करने
से रोक देगा, जबकि
अगर इसका क्लास है,
तो मैं कुछ जांच कर
सकता हूं और रक्षा
कर सकता हूं अमान्य
मान नहीं लिया जा
रहा है।
तो, कुछ अन्य आह .. अतिरिक्त
चीजों को देखने का
अधिकार देता है।
आइए कहते हैं कि मैं
दिन की शुरुआत करना
चाहता हूं।
मेरे पास Y, M और D हैं
जो तीन पूर्णांकों
के रूप में पारित
किए गए हैं और मैं

English: 
First quadrant is anything including 0, 0
or origin, right.
So, the first quadrant is anything including
0, 0 and if I move to the right or I move
up, that would be the first quadrant in a
plane.
I want to be able to ensure that at no point
of time, this point gets out of the first
quadrant.
I don't want to do manipulations or I don't
want to allow manipulations to go out of the
first quadrant.
If I want to do things like that, then I will
do operations and always check whether the
data is still in the first quadrant or not,
and report an error if it gets out of the
first quadrant for things like this.
So, to check validity, its always useful to
do this.
To allow ah.. classes to be defined and the
classes can also go and check for the validity,
right..
So, lets see how this whole thing would look
like.
So, I was talking about this function called
Date.
This Date has a special function which carries
the same name as the ah.. class’s name.

Malayalam: 
int date::season എന്ന് വിളിക്കുന്ന
ഒരു ഫംഗ്ഷൻ (function) ഞാൻ
രൂപകൽപ്പന ചെയ്യുന്നുവെന്ന്
പറയാം. ശീതകാലം, വസന്തകാലം,
വേനൽ, ശരത്കാലം എന്നിവയെ
ആശ്രയിച്ച് ഇത് 0,
1, 2 അല്ലെങ്കിൽ 3 നൽകണം.
Int date::season എന്താണ് ചെയ്യേണ്ടതെന്ന്
പറയാം; ഇതിനർത്ഥം
നിങ്ങൾ സീസൺ (season) എന്ന്
വിളിക്കുന്ന ഒരു
ഫംഗ്ഷനാണ് (function) നോക്കുന്നതെന്നാണ്,
ഇത് ഈ ക്ലാസ്സിനുള്ളിൽ
(class) date എന്ന് വിളിക്കുന്നു.
Date എന്ന് വിളിക്കുന്ന
ക്ലാസിന് season എന്ന്
വിളിക്കുന്ന ഒരു
ഫംഗ്ഷൻ (function) ഇല്ല.
കംപൈലർ അത് പിശകാണെന്ന്
പറയും.
പ്രൈവറ്റ്, പബ്ലിക്
(private, public) എന്നിവ ഉപയോഗപ്രദമായ
ഒരു കാര്യമാണ്. ഡിഫോൾട്ട്
(default) ആയി നമ്മൾ എല്ലാം
പൊതുവാക്കില്ല, കാരണം
കാര്യങ്ങൾ പ്രൈവറ്റ്
(private) ആയി സൂക്ഷിക്കുന്നതിലൂടെ,
വളരെ നല്ല ഒരു ഇന്റർഫേസ്
(interface) നൽകാൻ കഴിയും,
മാത്രമല്ല മാറ്റമില്ലാത്തവ
നിലനിർത്താനും കഴിയും.
പ്രോഗ്രാമുകൾ (program)
ഡീബഗ്ഗ് (debg) ചെയ്യുന്നതിനും
ഇത് സഹായിക്കും,
കാരണം നിങ്ങൾ എന്തെങ്കിലും
മാനിപുലേറ്റ് (manipulate)
ചെയ്യുകയും എന്തെങ്കിലും
തെറ്റ് സംഭവിക്കുകയും
ചെയ്തിട്ടുണ്ടെങ്കിൽ,
വേരിയബിളുകൾ (variable)
കൈകാര്യം ചെയ്യാൻ
കഴിയുന്ന ഫംഗ്ഷനുകളിലൂടെ
(function) മാത്രമേ ഇത്
സംഭവിക്കൂ. പുറത്തുള്ള
മറ്റെന്തെങ്കിലും
വഴി ഇത് സംഭവിക്കാൻ
കഴിയില്ല. എന്തെങ്കിലും
മാനിപുലേഷൻ (manipulation)

Hindi: 
इस DD को सेट करना चाहता
हूं जो डेट डेटा प्रकार
का एक संकेतक है।
तो, मैं चाहता हूँ
कि dd, y, m और d का मान
y, m और d हो जो पास हो।
इसलिए, हो सकता है
कि मैं इस तरह का एक
फ़ंक्शन चाहता हूं,
इस स्ट्रक्चर(structure)
के सदस्यों को कुछ
मूल्यों के लिए आरंभीकृत
करें या मैं एक निश्चित
संख्या को कुछ दिनों
के प्रकार में जोड़ना
चाह सकता हूं।
तो, मान लें कि वर्तमान
तिथि 30 दिसंबर 1950 है,
और मैं इसमें 2 दिन
जोड़ना चाहता हूं
और 1 जनवरी, 1951 को स्थानांतरित
करना चाहता हूं।
मान लीजिए कि मैं
ऐसा करना चाहता हूं।
मैं इसे करने में
सक्षम होना चाहिए।
कुछ दिन जोड़ें और
एक ऐसा तंत्र है जिसके

English: 
So, you can see that blue and red one, they
have the same name, right.
The constructors always take the same name
as the class.
In this case, the constructor is the method
which takes three integers yy, mm and dd and
what it does is, it assigns your local variable
y to yy and the local variable m is assigned
the value mm, and the local variable d is
assigned the value dd.
So, if you create an object of the type Date
and if you put Date of 12, ah..
30, 1950, internally you can write code within
the constructor which will go and check that
and say that its invalid, right.
However, if its valid, it initializes it and
this check that you do inside the code may
just leave it as it is.

English: 
So, if I end up define, lets say I design
a function called int Date colon colon season.
This is supposed to return 0, 1, 2 or 3 depending
on whether its winter, spring, summer and
autumn.
Lets say thats what we want to do if you do
int Date colon colon season; it means you
are looking at a function called season which
is a method inside this class called Date.
However, the class called Date does not have
a method called season.
The compiler will catch it and tell you that
its an error.
So, this notion of public and private is a
useful distinction to make.
We don't make everything public by default
because ah.. by keeping things private, we
can provide a very clean interface and we
can also maintain things which are supposed
to be invariance.
What is the validity of the data inside, we
can maintain the invariance.
This can also help in debugging programs because
if you manipulated something and if something
went wrong, it could have happened only through
functions that manipulate that can manipulate

Malayalam: 
നടന്നിട്ടുണ്ടെങ്കിൽ,
അത് സംഭവിച്ചത് ഈ
മെത്തേഡുകളിലൂടെ
(method) ആണെന്നും ഈ മെത്തേഡുകളിൽ
(method) എന്തെങ്കിലും
തെറ്റുണ്ടെന്നും
പറയാം. ക്ലാസ് (class)
എന്ന ആശയം ആന്തരിക
പ്രാതിനിധ്യം മാറ്റാൻ
അനുവദിക്കുന്നു.
ഇത് വിശദമായി കാണും
പിന്നീടുള്ള ക്ലാസ്സിൽ‌
(class) ADT യെയും ഡാറ്റാ
(data) ഘടനയെയും കുറിച്ച്
സംസാരിക്കുമ്പോൾ‌.
ഒരു ലിസ്റ്റിനായുള്ള
(list) ADT എന്ന നിലയിൽ,
ആന്തരികമായി ഒരു
ലിങ്ക് ലിസ്റ്റ്
(linked list) അല്ലെങ്കിൽ
ഒരു അറേ (array) ഉപയോഗിക്കാം.
ലിസ്റ്റ് (list) ഘടകങ്ങളുടെ
ഒരു ശ്രേണി മാത്രമാണ്.
എനിക്ക് ആന്തരികമായി
ഒരു അറേ (array) അല്ലെങ്കിൽ
ലിങ്ക് ലിസ്റ്റ്
(linked list) ഉപയോഗിക്കാമായിരുന്നു.
ഒരു ലിസ്റ്റ് (list)
ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന
ഒരാളിൽ നിന്ന് ഇത്തരത്തിലുള്ള
നടപ്പാക്കൽ വിശദാംശങ്ങൾ
മറയ്ക്കാൻ കഴിയും,
ക്ലാസുകൾ (class) ഉപയോഗിക്കുകയാണെങ്കിൽ
ഇത് സാധ്യമാണ്
ഒരു നല്ല ഇന്റർഫേസ്
(interfcae) എന്താണെന്നു
നോക്കാം. ഒരു ഇന്റർഫേസ്
(interface) ചുരുങ്ങിയ രീതിയിൽ
ക്ലാസുകൾ നിർവചിക്കുന്നു.
ഇത് കഴിയുന്നത്ര
ചെറുതായിരിക്കണം,
അതേ സമയം, അത് പൂർണ്ണമായിരിക്കണം.
എല്ലാ അടിസ്ഥാന കാര്യങ്ങളും
കഴിയണം. ആന്തരിക

Hindi: 
द्वारा मैं न केवल
पहचानता हूं कि 30
दिसंबर से 2 दिन 32 दिसंबर
नहीं है।
वास्तव में, दिसंबर
में भी नहीं, जनवरी
में भी और इस साल के
जनवरी में भी नहीं,
वास्तव में अगले
साल तक बढ़ रहा है।
इसलिए, यदि मैं 30 दिसंबर,
1950 तक 2 दिन जोड़ता
हूं, तो आंतरिक रूप
से मैं चाहता हूं
कि यह स्वचालित रूप
से 1 जनवरी 1951 को स्थानांतरित
हो जाए।
वास्तव में, मैं लीप
वर्ष और इसलिए भी
उपयुक्त तरीके से
मामलों को संभालना
चाहता हूं।
इन सभी विवरणों को
मैं प्रोग्रामर के
सामने उजागर नहीं
करना चाहता।
तो, यह बहुत बोझिल
हो जाता है।
मैं प्रोग्रामर को
जो कुछ देना चाहता

Hindi: 
हूं, वह इंटरफ़ेस
के रूप में add_day है।
स्तृक्तुरेस के साथ
आसानी से संभव नहीं
है क्योंकि आप हमेशा
इन तरीकों से गुजरने
के बिना इन मूल्यों
को आ सकते हैं और उनमें
हेरफेर कर सकते हैं।
आप यह समझ सकते हैं
कि वृध्दि d को सीधे
बिना यह समझे कि tuple
d, m, y वैध नहीं है।
आप ऐसा कर सकते हैं,
लेकिन यदि आपको हमेशा
फ़ंक्शन के रूप में
add_day से गुजरने के लिए
मजबूर किया जाता
है, तो add_day को बहुत
अधिक क्लीनर तरीके
से लागू किया जा सकता
है और सभी त्रुटियों
की जाँच की जा सकती
है और फ़ंक्शन को
लागू किया जा सकता
है।

English: 
the variables.
It could not have happened through something
else which is outside.
So, you can go and round up the usual suspects
essentially and say that if manipulations
happened, it happened only through these methods
and there is something in these methods which
is incorrect.
And you will also see that ah.. it allows
you to change the internal representation.
The notion of a class allows you to change
the ah.. internal representation.
This is something that you will see in a lot
of detail ah.. in a later class when we talk
about the notion of adt and data structures,
right.
So, as an adt for a list, could use a link
list internally or it could use an array internally.
The notion of a list is just a sequence of
elements.
I could have used an array internally or I
could have used a link list internally.
This kind of implementation detail can be
hidden from somebody who just wants to use
a list and this is possible if you use classes.

Malayalam: 
ലോകത്തിന് തുറന്നുകാട്ടാൻ
ആഗ്രഹിക്കുന്ന കാര്യങ്ങൾ
ബാഹ്യ ലോകത്തിൽ നിന്ന്
സുരക്ഷിതമായിരിക്കണം.
ആർ‌ഗ്യുമെൻറുകൾ‌
(argument) മറ്റൊരു വിധത്തിൽ‌
പാസ് ചെയ്യാൻ പാടില്ല,
ഇത് ടൈപ്പ് സേഫ്
(typesafe) ആയിരിക്കണം.
സി പ്ലസ് പ്ലസ് (C++)
ഇൽ ലിങ്ക്ഡ് ലിസ്റ്റ്
(linked list) എങ്ങനെ നിർവചിക്കാമെന്ന്
നോക്കാം. നോഡ് (node)
എന്ന ക്ലാസ് (class) നിർവചിക്കുന്നു.
ഇത് ഒരു സ്ട്രക്ച്ചറുമായി
(structure) വളരെ സാമ്യമുള്ളതാണ്,
സ്ട്രക്റ്റ് നോഡ്
ഡാറ്റയും (struct node data)
അടുത്തതായി, ഇവിടെ
ക്ലാസ് നോഡും (class
data) ഉണ്ട്, അവിടെ പ്രൈവറ്റ്
മെമ്പറുകൾ (private member)
ഡാറ്റയും (data) നെക്സ്റ്റും
(next) ആണ്. പബ്ലിക് മെത്തേഡുകളും
(public method) നൽകുന്നു.
സെറ്റ്ഡാറ്റയും
(setdata) സെറ്റ്നെക്സ്റ്റും
(setnext) ഉണ്ട്, അത് ഡാറ്റ
(data) സെറ്റ് (set) ചെയ്യാനും
നെക്സ്റ് (next) സെറ്റ്
(set) ചെയ്യാനും വേണ്ടിയാണ്.
ഡാറ്റ (data) നെക്സ്റ്
(next) എന്നീ മെത്തേഡുകൾ
(method) ഡാറ്റ യും (data)
നെക്സ്റ്റും (next) റിട്ടേൺ

English: 
So, ah.. many times we go and look at what
makes a good interface.
So, we define classes in such a way that an
interface is minimal.
It should be as small as possible, at the
same time, it has to be complete.
So, it has to be small, it has to be small
enough to do all the basic things, but not
any smaller than that.
It has to be the smallest and elegant ah..
set of things that you want to expose to the
internal world, ah.. to the external world
I mean and it has to be safe.
So, you don't want to have the arguments passed
in a different manner and so on you ensure
that it is type safe.
So, lets see how to define the linked list
in a C plus plus way.
This is what I was promising earlier, right.
So, to define linked list in a C plus plus
way, you would do something like this.
We define a class called Node.
This is very similar to a structure, right.
So, we had struct Node data and next, here
we have class Node where the private members
are data and next.

Hindi: 
तो, यह हमेशा सही रहे।
तो, इस पर एक छोटा
सा उदाहरण देखें।
मेरे पास ईंट y, m, d है।
मैं हमेशा आह चाहता
हूं .. तारीखों के
लिए कुछ वैध मूल्य।
इसलिए, मैं चाहता
हूं कि जिसे कंस्ट्रक्टर
कहा जाए।
इसलिए, किसी भी समय
इस ऑब्जेक्ट को तारीख
कहा जाने वाला है,
इसे वैध मानों की
आपूर्ति करनी होगी,
अन्यथा यह गलत होगा
और मैं ऐड डे का समर्थन
करना चाहता हूं।
इसलिए, भले ही यह स्तृक्त
डेट के साथ दिया गया
हो, यह वैध सिंटैक्स
नहीं है।
तो, हम यहाँ क्लास
तिथि चाहते हैं, और
क्लास दिनांक में
तीन सदस्य होंगे
y, m और d और इसकी दो विधियाँ
होंगी तिथि जो तीन

Malayalam: 
(return) ചെയ്യുന്നു. ഈ
രണ്ട് മെത്തേഡുകളും
(method) നോഡിലേക്ക് (node)
അക്സസ്സ് (access) നൽകുന്നു,
ഇവ രണ്ടും ഉപയോഗിച്ച്
മാറ്റം വരുത്താൻ
അനുവാദമുണ്ട്, കൂടാതെ
ഇവ രണ്ടും ഉപയോഗിച്ച്
റീഡ് (read) ചെയ്യാൻ
അനുവാദമുണ്ട്. നോഡ്
(node) എന്ന കൺ‌സ്‌ട്രക്റ്റർ‌
(constructor) ഉണ്ട്. ഇത് ഒന്നും
ചെയ്യുന്നില്ല. ഇതാണ്
അടിസ്ഥാന ക്ലാസ്
(class), ലിങ്ക്ഡ് ലിസ്റ്റിനുള്ളിൽ
(linked list) ഈ ക്ലാസ് (class)
ഉപയോഗിക്കാൻ പോകുന്നു.
ലിങ്ക്ഡ് ലിസ്റ്റിൽ
(linked list) എന്താണ് ഉള്ളത്?
ലിങ്ക്ഡ് ലിസ്റ്റിൽ
(linked list) ഫസ്റ്റ് (first)
എന്ന് വിളിക്കുന്ന
ഒരു നോഡ് (node) ഉണ്ട്.
പ്രിന്റ് (print), അപ്പെൻഡ്
(append), ഡിലീറ്റ് (delete)
എന്നിങ്ങനെയുള്ള
വിവിധ പ്രവർത്തനൾ
ഉണ്ട്. കൂടാതെ ഇതിന്
ലിസ്റ്റ് (list) എന്ന
ഒരു കൺ‌സ്‌ട്രക്റ്റർ‌
(constructor) ഉണ്ട്. തുടക്കത്തിൽ
ശൂന്യമായ ഒരു ലിസ്റ്റ്
(list) വേണമെങ്കിൽ, ചെയ്യേണ്ടത്
സാധുവായ നോഡ് (node)
ഇല്ലെന്ന് ഉറപ്പുവരുത്തുക
എന്നതാണ്. ലിസ്റ്റിലെ
(list) എന്തെങ്കിലും
കൈകാര്യം ചെയ്യാൻ
നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ,

English: 
We also provide public methods.
Lets look at the public methods.
You have SetData and SetNext which will let
data and next to be changed, and we have data
and next which will which will do the get.
So, these two methods give you get and these
two methods give you put access to Node, right.
So, you are allowed to change with these two
and you are allowed to read using these two.
And there is another method called Node which
is the constructor for class Node.
This is not doing anything.
So, its not changing anything at all.
So, its not ah.. setting up anything.
So, this is the basic class and we are going
to use this class inside the linked list.
So, what does the linked list have?
The linked list has a Node called the first
node, right.
So, the linked list has a first node and it
supports various operations like Print, Append,

Malayalam: 
നിങ്ങൾ ഇവിടെ ഈ ഫംഗ്ഷനുകളിലൂടെ
(function) കടന്നുപോകണം;
അപ്പെൻഡ് (append), ഡിലീറ്റ്
(delete), പ്രിന്റ് ഫസ്റ്റ്
(print first) പ്രൈവറ്റ്
(private) ആയതിനാൽ നേരിട്ട്
ആക്‌സസ് (access) ചെയ്യാൻ
കഴിയില്ല. പ്രിന്റ്
(print), അപ്പെൻഡ് (append),
ഡിലീറ്റ് (delete) എന്നീ
ഇന്റർഫേസ് (interface) പ്രവർത്തനങ്ങളിലൂടെ
മാത്രമേ നിങ്ങൾക്ക്
പോകാൻ കഴിയൂ.
പ്രിന്റ് മെത്തേഡ്
(print method) എങ്ങനെയിരിക്കുമെന്ന്
നോക്കാം. Node *tmp = first.
ടെം‌പ് (tmp) ശൂന്യമാണെങ്കിൽ‌
ലിസ്റ്റ് (list) ശൂന്യമാണ്.
സ്‌ക്രീനിൽ‌ (screen)
എംപ്റ്റി (empty) എന്ന്
പ്രിന്റുചെയ്യാം.
Tmp ->next = NULL ആണെങ്കിൽ
ലിസ്റ്റിൽ‌ (list) ഒരു
നോഡ് (node) മാത്രമേ
ഉള്ളൂവെങ്കിൽ‌, ആദ്യത്തെ
നോഡിന്റെ (node) നെക്സ്റ്
(next) ശൂന്യമായിരിക്കും.
നെക്സ്റ് ഫീൽഡ് (next
filed) ഉപയോഗിക്കാതെയാണ്
ഇത് ചെയ്യുന്നത്,
tmp ->next() എന്ന മെത്തേഡ്
(method) കോൾ (call) ചെയ്യുന്നു.
അത് നൾ (NULL) ആണെങ്കിൽ
tmp ->data യിൽ‌ അടങ്ങിയിരിക്കുന്ന
കാരക്ടർ (character) പ്രിന്റു
(print) ചെയ്യുക, തുടർന്ന്
നൾ (NULL) പ്രിന്റ് (print)

Hindi: 
प्रारंभिक मूल्यों
को लेगी और add_days जो
आह करेगा .. जो आह जोड़
देगा .. निश्चित वर्तमान
तिथि के दिनों की
संख्या।
इसलिए, जिस क्षण आप
ऐसा करते हैं, यदि
आप दिनांक my_birthday करते
हैं, तो यह गलत होगा
क्योंकि इसका प्रारंभ
नहीं हुआ है।
यदि आप दिनांक 12, 30,
1950 की तारीख my_birthday करते
हैं, तो वर्ष 12 है,
माह 30 है और दिन 1950
है।
add_day को इस तरह से लिखा
जा सकता है कि इसे
एक त्रुटि के रूप
में पहचाना जा सकता
है और यह संकेत दिया
जा सकता है।
हालाँकि, अगर आप 1950,
12, 30 की तारीख my_day करते
हैं, तो यह आह होगा
.. एक वैध दिन के रूप

Hindi: 
में मान्यता प्राप्त
है और बाद में अगर
मैं 2 का my_birthday डॉट add_day
करता हूं, तो जन्मदिन
आह से चलता है .. 30 दिसंबर
1950 से 1 जनवरी 1951 तक।
तो, यह आह .. साफ है।
हालाँकि, अगर मैं
my_birthday डॉट m 14 करता हूं,
तो यह अमान्य होगा
क्योंकि आप सीधे
सदस्य m को एक्सेस
कर रहे हैं और यह सही
नहीं है।
इसलिए, यदि आप क्लाससेस
करते हैं, तो ऐसा करने
का तरीका आपके पास
y, m और d निजी है और आपके
पास सभी विधियाँ
सार्वजनिक हैं।
इसलिए, दिनांक सार्वजनिक
है।
add_day वास्तव में y के
कोन्तेंट्स को चंगे
करेगा, y और d की सामग्री
को बदल देगा और हमारे
पास तीन विधियाँ
हैं जिन्हें महीने,

English: 
Delete and so, on and it has a constructor
called List.
Ah.. if I want an initially empty list, all
its supposed to do is ensure that there is
no valid node thats pointed to from it.
So, first equals null thats it.
So, now, you can see that the notion of a
linked list becomes much cleaner, right.
So, if you want to manipulate anything in
the list, you have to go through these functions
here; Append, Delete and Print.
You cannot go and access first directly because
by default first is private.
You cannot access first directly.
You can only go through the interface functions
namely Print, Append and Delete.
Lets see how a print method would look like.
So, the implementation of print would look
like this.
So, Node star temp equals first.
If temp itself is null which means its an
empty list, you may want to print empty on
the screen.

Malayalam: 
ചെയ്യുക. അല്ലാത്തപക്ഷം
ഒരു ഡു വയിൽ ലൂപ്പ്
(do while loop) പ്രവർത്തിപ്പിക്കുന്നു,
അത് ഒരു സമയം ഒരു
കാരക്ടർ (character) പ്രിന്റു
(print) ചെയ്യുന്നു, ഞങ്ങൾ
ഡാറ്റാ (data) ഘടകത്തിലേക്കോ
നോഡുകളുടെ (node) നെക്സ്റ്റ്
പോയിന്ററിലേക്കോ
(next pointer) നേരിട്ട് അക്സസ്സ്
(access) ചെയ്യുന്നില്ല.
അത് ചെയ്യുന്നതിന്
മെത്തേഡുകൾ (method) കോൾ
(call) ചെയ്യുന്നു. ലിസ്റ്റിന്റെ
(list) അവസാനം വരെ ഇത്
ചെയ്യുന്നത് തുടരും.
ഈ അടിസ്ഥാന ലൂപ്പ്
(loop) നോഡുകളിൽ (node) നിന്ന്
ഒരു സമയം ഒരു ഘടകം
വായിക്കുന്നതും
പൂജ്യം മൂലകം അല്ലെങ്കിൽ
ഒരു മൂലകം അല്ലെങ്കിൽ
ഒന്നിൽ കൂടുതൽ ഘടകങ്ങൾ
ഉണ്ടോ എന്നതിനെ അടിസ്ഥാനമാക്കി
അവ അച്ചടിക്കുന്നതും
ശ്രദ്ധിക്കുന്നു.
പ്രിന്റ് (print) എന്ന്
കോൾ (call) ചെയ്യുന്ന
ഏതൊരാൾക്കും അതിന്റെ
ശൂന്യമായ പട്ടിക
ഉണ്ടോ അല്ലെങ്കിൽ
അതിൽ ഒരു ഘടകമോ അതിൽ
കൂടുതലോ ഉണ്ടോ എന്ന്
വിഷമിക്കേണ്ടതില്ല.
വിശദാംശങ്ങൾ‌ ഉപയോക്താവിൽ‌
നിന്നും മറച്ചിരിക്കുന്നു.

Malayalam: 
ഉപയോക്താവിന് പ്രിന്റ്
(print) മാത്രം കോൾ (call)
ചെയ്ത് അത് ഉപയോഗിച്ച്
പൂർത്തിയാക്കുക.
ലിസ്റ്റിലേക്ക്
(list) കൂട്ടിച്ചേർക്കുന്നത്
കാണാം. ലിസ്റ്റിന്റെ
(list) അവസാനത്തിൽ‌ ഒരു
ഘടകം ചേർ‌ക്കാൻ‌
ഞങ്ങൾ‌ ശ്രമിക്കുന്നു.
ഒരു പുതിയ നോഡ് (node)
സൃഷ്ടിക്കുന്നു,
കൈമാറിയ ഡാറ്റയിലേക്ക്
(data) അതിന്റെ ഡാറ്റ
(data) സജ്ജമാക്കുന്നു.
അപ്പെൻഡ് (append) ഒരു
ഡാറ്റ (data) എടുക്കേണ്ടതാണ്,
അത് ഡാറ്റയെ (data) അവസാനത്തേതായി
സജ്ജമാക്കുകയും
നെക്സ്റ്റ് പോയിന്റർ
(next pointer) ശൂന്യമായി
സജ്ജമാക്കുകയും
ചെയ്യുന്നു. നോഡ്
ന്റെ (node) ഒരു പുതിയ
ഒബ്ജക്റ്റ് (object) സൃഷ്ടിക്കുകയും
ഒരു താൽക്കാലിക വേരിയബിൾ
(variable) ഉപയോഗിച്ച്
ആരംഭിക്കുകയും ചെയ്യുന്നു.
ലിസ്റ്റ് (list) ശൂന്യമാണെങ്കിൽ,
first = newNode, കാരണം മറ്റൊന്നും
ചെയ്യാനില്ല. ഒരു
പുതിയ നോഡ് (node) സൃഷ്ടിച്ചു,
ഫസ്റ്റ് പോയിന്റർ
(first pointer) അതിലേക്ക്
പോയിന്റു (point) ചെയ്യും.
ഇത് ഒരു ശൂന്യമായ
ലിസ്റ്റ് (list) അല്ലെങ്കിൽ
ലിസ്റ്റിന്റെ (list)
അവസാനം എത്തുന്നത്
വരെ പോയിന്റർ (pointer)
നീക്കുന്നു. ലിസ്റ്റിലൂടെ
(list) സഞ്ചരിക്കുന്ന

Hindi: 
दिन और वर्ष कहा जाता
है और ये तीन विधियाँ
वास्तव में वर्तमान
महीने, वर्तमान दिन
और वर्तमान वर्ष
लौटाती हैं।
तो, ये तीन विधियाँ
आपको डेटा तक केवल
पढ़ने की पहुँच प्रदान
करती हैं।
दिनांक लिखित पहुँच
देने वाली है।
आप y, m और d की सामग्री
को बदल सकते हैं और
add_day y, m और d की सामग्री
को भी बदल सकते हैं।
तो, 1950, 12, 30 की तारीख
माइ_बर्थड़े (my_birthday)
के y, m और d ये तीन मूल्य
हैं और मैं printf प्रतिशत
d माइ_बर्थड़े (my_birthday)
dot month कर सकता हूं और
माइ_बर्थड़े (my_birthday)
dot मंथ(month) एक विधि है।
यदि हम जाकर उस विधि
को देखते हैं, तो यह
m लौटता है और m का मान
क्या है, इसकी संख्या
12 होनी चाहिए।
तो ये 12 प्रिंट करेगा।
हालाँकि, अगर मैं
my_birthday डॉट एम 14 है; संकलक
इसे तब भी पकड़ेगा
जब आप इसे संकलित
करेंगे, संकलनकर्ता
इसे पकड़ लेगा और
कहेगा कि m एक निजी
विशेषता है।
इसमें सीधे हेरफेर
नहीं किया जा सकता
है।
इसलिए, यदि आप m में
हेरफेर करना चाहते

English: 
If temp, if there is only one node in the
list, then the first node's next will be null.
We actually do this not using the next field,
but we call the method called next temp's
next.
If that returns null, then print the character
which is contained in temp data and then,
followed by arrow null.
Otherwise we run a do while loop which prints
one character at a time and the way do we
do that is, we don't access the data element
or the next pointer of the of the nodes directly.
We call the method's temp data and temp next
to do that and we keep doing this till we
hit the end of the list.
So, this basic loop takes care of reading
one element at a time from the nodes and printing
them based on whether there is only zero element
or one element or more than one element.

Malayalam: 
ഇത്തരത്തിലുള്ള
ഒരു സജ്ജീകരണം പുറം
ലോകത്തിൽ നിന്ന്
പൂർണ്ണമായും മറഞ്ഞിരിക്കുന്നു,
പുറം ലോകത്ത് നിന്ന്
മറക്കുന്നു എന്നത്
കൊണ്ട് ഞാൻ എന്താണ്
ഉദ്ദേശിക്കുന്നതെന്ന്
വിശദീകരിക്കാം.
ക്ലാസുകളെക്കുറിച്ചുള്ള
(class) ഈ ആശയം മുഴുവൻ
പ്രോഗ്രാമിനെയും
(program) എത്രമാത്രം വൃത്തിയാക്കുന്നുവെന്ന്
കാണിക്കുന്ന ഒരു
ചെറിയ പ്രോഗ്രാം
(program) എഴുതുക. ഒരു പുതിയ
ലിങ്ക്ഡ് ലിസ്റ്റ്
(linked list) സൃഷ്‌ടിക്കാൻ
ഞാൻ ആഗ്രഹിക്കുന്നു,
ഒപ്പം a, b, c, d ഘടകങ്ങൾ
ചേർക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു,
ലിസ്റ്റിലെ (list) b ഘടകം
ഇല്ലാതാക്കാൻ ഞാൻ
ആഗ്രഹിക്കുന്നു.
ഇവിടെ ഞാൻ ലിസ്റ്റ്
(list) എന്ന് വിളിക്കുന്ന
ഒരു വേരിയബിൾ (variable)
അല്ലെങ്കിൽ ഡാറ്റാ
(data) തരം ലിസ്റ്റിലുള്ള
(list) ഒബ്ജക്റ്റ് ലിസ്റ്റ്
(object list) പ്രഖ്യാപിക്കുന്നു,
a, b, c, d എന്നിവ ലിസ്റ്റിൽ
(list) ചേർക്കാൻ പോകുന്നു.

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

English: 
So, this is clean because any one who calls
print does not have to worry whether its an
empty list or does it contain one element
or more.
So, the print itself takes care of the implementation.
The detail is hidden from the ah.. user.
So, the user can just call ah.. print and
be done with it.
Lets see append to the list.
So, for appending to the list, ah.. we are
going we are trying to add an element to the
end of the list.
So, we create a new node, we set its data
to the data that is passed.
So, append is supposed to take a data and
it sets the data to the last and sets the
next pointer to null.
So, you create a new object of the type Node
and you start with a temporary variable here
which points to first.
If the list is empty, then you just make first
equals new Node because there is nothing else
to do.

English: 
You created a new Node and the first pointer
will point to that.
However, if it is not an empty list, then
we keep moving the pointer till we hit the
end of the list at that point we insert it.
So, this kind of a set up where we traverse
the list and so, on is completely hidden from
the outside world, right.
So, let me explain what I mean by hidden from
the outside world by showing how the program
will look like.
Let me ah.. write a small program which shows
how clean this notion of classes makes the
whole program.
So, I want to create a new linked list and
I want to add elements a, b, c and d and may
be at a later point of time, I want to even
delete the element b in the list.
So, here I declare a variable called list
or an object list which is of the data type
List and this Append a, b, c and d is going
to add these characters a, b and c and d to

Hindi: 
तो, पहला चतुर्थांश
0, 0 सहित कुछ भी है
और अगर मैं दाईं ओर
बढ़ता हूं या मैं
ऊपर जाता हूं, तो यह
एक प्लेन में पहला
चतुर्थांश होगा।
मैं यह सुनिश्चित
करना चाहता हूं कि
किसी भी समय यह बिंदु
पहले चतुर्थांश से
बाहर न हो जाए।
मैं जोड़तोड़ नहीं
करना चाहता या मैं
पहले चतुर्थांश से
बाहर जाने के लिए
जोड़तोड़ की अनुमति
नहीं देना चाहता।
अगर मैं ऐसी चीजें
करना चाहता हूं, तो
मैं ऑपरेशन करूंगा
और हमेशा जांच करूंगा
कि क्या डेटा अभी
भी पहले क्वाड्रेंट
में है या नहीं, और
अगर यह इस तरह की चीजों
के लिए पहले क्वाड्रेंट
से बाहर निकलता है
तो एक त्रुटि की रिपोर्ट
करेगा।

Malayalam: 
വാക്യഘടന എങ്ങനെയെന്ന്
നോക്കാം. ലിസ്റ്റ്
(list) ഒരു ഒബ്ജക്റ്റ്
(object) ആണ്. Object.append എന്ന്
ഞാൻ പറയുമ്പോൾ, ഈ
ഒബ്‌ജക്റ്റ് (object)
ഡാറ്റാ (data) തരം ലിസ്റ്റിലാണ്.
അപ്പെൻഡ് (append) എന്ന
പേരിൽ ഒരു മെത്തേഡ്
(method) ഉണ്ടോ എന്ന് കണ്ടെത്താൻ
ഇത് പോകുന്നു; അപ്പെൻഡ്
(append) ഒരു കാരക്ടർ (character)
എടുക്കുന്നു. അതിനാൽ,
ഞങ്ങൾ ഒരു കാരക്ടർ
(character) കൈമാറുന്നു,
കൂടാതെ list.append ലിസ്റ്റിൽ
(list) a ചേർക്കുന്നു.
ഈ സമയത്ത്, ഈ ലിസ്റ്റ്
(list) ശൂന്യമാണ്. അതിനെക്കുറിച്ച്
ഞങ്ങൾ വിഷമിക്കേണ്ടതില്ല.
list.append (a) ചെയ്യുമ്പോൾ
ഒരു നോഡ് (node) സൃഷ്ടിക്കും.
നിങ്ങൾ ആദ്യ പോയിന്റർ
(pointer) പുതിയ നോഡിലേക്ക്
(node) മാറ്റിയേക്കാം,
ഒരു നോഡ് (node) ഉപയോഗിച്ച്
ലിസ്റ്റ് (list) സൃഷ്ടിച്ചയുടനെ,
നിങ്ങൾക്ക് അത് പ്രിന്റു

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

English: 
the list.
Lets see how the syntax is.
So, list is an object.
When I say object dot Append, this object
is of the data type List.
So, its going to find out if there is a method
by the name Append; and what does it take.
Append takes that ah.. data type character.
So, we are passing a character and list dot
append will ah.. add a to the list.
At this point of time, this list is empty.
We don't have to worry about that.
We we just said list dot Append of a, and
the first time ah..
Append is called, inside here you would create
a node.
This would be not true.
You would just change the first pointer to
newNode and maybe we can print it even.
As soon as you create ah.. list with one node,
you can print it and then, we do list dot
Append of b.

Malayalam: 
(print) ചെയ്യാം, തുടർന്ന്
ഞങ്ങൾ list.append(b) ചെയ്യുന്നു.
ഈ ഘട്ടത്തിൽ‌ ലിസ്റ്റിൽ
(list) ഒരു നോഡ് (node) ഉണ്ട്.
ഇപ്പോൾ മെത്തേഡ്
(method) നോക്കും ഇത് ആദ്യത്തെ
നോഡല്ല (node). അതിനാൽ,
അത് ലിസ്റ്റിലൂടെ
(list) പോകും, ​​നൾ (NULL)
എത്തുന്നത് വരെ പോയിട്ട്
അത് ചേർക്കും. ഇപ്പോൾ
a 
b യിലേക്ക് പോയിന്റ്
(point) ചെയ്യുന്നു. തുടർന്ന്
b c യിലേക്ക് പോയിന്റു
(point) ചെയ്യും, നിങ്ങൾ
പ്രിന്റു (print) ചെയ്യുമ്പോൾ,
നിങ്ങൾ ആദ്യത്തെ
പോയിന്ററിൽ (pointer) നിന്ന്
ആരംഭിച്ച്, a, b, c മുതലായവ
പ്രിന്റു (print) ചെയ്‌ത്
അവസാനത്തിലേക്ക്

Hindi: 
पूर्णांक yy, mm और dd
लेता है और यह क्या
करता है, यह आपके स्थानीय
चर y को yy को निर्दिष्ट
करता है और स्थानीय
चर m को मान mm, और स्थानीय
चर d को असाइन किया
गया है मान dd।
इसलिए, यदि आप प्रकार
दिनांक का एक ऑब्जेक्ट
बनाते हैं और यदि
आप 12 की तारीख डालते
हैं, तो आह .. 30, 1950, आंतरिक
रूप से आप कंस्ट्रक्टर
के भीतर कोड लिख सकते
हैं, जो जाकर जांच
करेगा और कहेगा कि
ये अमान्य है, सही
है।
हालाँकि, यदि इसकी
वैधता है, तो यह इसे
प्रारंभ करता है
और यह जाँच करता है
कि आप कोड के अंदर
ही इसे छोड़ सकते
हैं जैसा कि यह है।
इसलिए, अगर मैं अंत
में परिभाषित करता
हूं, तो मैं कहता हूं
कि मैं एक फ़ंक्शन
डिज़ाइन करता हूं
जिसे इंट डेट कोलोन
कोलोन सीज़न कहा
जाता है।
यह 0, 1, 2 या 3 को वापस
करने के लिए माना
जाता है कि क्या इसकी
सर्दी, वसंत, गर्मी
और शरद ऋतु।
यदि आप इंट डेट कोलन
कोलोन सीज़न करते
हैं तो हम जो करना
चाहते हैं वह कहते
हैं; इसका मतलब है
कि आप एक फंक्शन देख
रहे हैं जिसे सीज़न
कहा जाता है जो इस
क्लास के अंदर एक
विधि है जिसे डेट
कहा जाता है।
हालाँकि, दिनांक
नामक क्लास में एक
विधि नहीं होती है
जिसे सीज़न कहा जाता
है।
संकलक इसे पकड़ लेगा
और आपको बताएगा कि
इसकी त्रुटि है।
इसलिए, सार्वजनिक
और निजी की यह धारणा
बनाने के लिए एक उपयोगी
अंतर है।
हम डिफ़ॉल्ट रूप
से सब कुछ सार्वजनिक
नहीं करते क्योंकि
आह .. चीजों को निजी
रखने से, हम एक बहुत
ही स्वच्छ इंटरफ़ेस
प्रदान कर सकते हैं
और हम उन चीजों को
भी बनाए रख सकते हैं
जो कि अदृश्य हैं।
अंदर डेटा की वैधता
क्या है, हम इन्वारियांके
को बनाए रख सकते हैं।
यह डिबगिंग प्रोग्राम्सस
में भी मदद कर सकता
है क्योंकि यदि आपने
किसी चीज़ में हेरफेर
किया है और यदि कुछ
गलत हुआ है, तो यह
केवल उन कार्यों
के माध्यम से हो सकता
है जो कि हेरफेर कर
सकते हैं जो चर को
हेरफेर कर सकते हैं।
यह किसी और चीज के
माध्यम से हो सकता
था जो बाहर है।
इसलिए, आप सामान्य
संदिग्धों को अनिवार्य

Malayalam: 
പോകുക. ഇപ്പോൾ, നിങ്ങൾക്ക്
d കൂട്ടിച്ചേർക്കാം.
ലിസ്റ്റിൽ (list) ഇപ്പോൾ
, b, c, d ഉണ്ടാകും, ഒടുവിൽ,
list.delete(b) എന്ന് വിളിക്കുകയാണെങ്കിൽ,
b ഡിലീറ്റ് (delete) ചെയ്യും.
ഒരു ഉപയോക്താവെന്ന
നിലയിൽ എനിക്ക് ലിങ്ക്ഡ്
ലിസ്റ്റ് (linked list) വേണം.
ലിസ്റ്റ് (list) എങ്ങനെയാണ്
നടപ്പിലാക്കിയത്,
അപ്പെൻഡ് (append), ഡിലീറ്റ്
(delete) എന്നിവ എങ്ങനെ
നടപ്പിലാക്കുന്നു
എന്നതിനെക്കുറിച്ച്
ഞാൻ വിഷമിക്കേണ്ടതില്ല;
അത് ക്ലാസിന്റെ (class)
ഡിസൈനർ‌ക്ക് (designer)
വിട്ടുകൊടുക്കുന്നു,
ഡിലീറ്റ് (delete) എന്ന
ഒരു ഫംഗ്ഷൻ‌ (function)
ഉണ്ടെങ്കിൽ‌, ഈ ഇല്ലാതാക്കൽ‌

English: 
At this point the list already contains a,
and ah.. now the method will look at this
is not the first node.
So, it will go through the list, find out
that ah.. the null is pointed from a.
At that point, it will add it.
So, a will now point to b.
If you do this, b will point to c and when
you print, you start from the first pointer,
print a, print b, print c and so, on and go
to the end.
Now, you can append d.
So, the list will have a, b, c, d and finally,
if you call list dot delete of b, if there
is a function implemented by the name Delete,
we assume that ah.. programmer has already
taken care of that.
The class's designer has taken care of Print
Append and Delete.
As a user of the class.
So, when I said user and programmer and so,
on till now I am talking about user of the
class, right.
So, the user of the class, so as a user I
want the linked list.

English: 
I don't want to worry about how the list is
ah.. implemented, how the append is implemented;
delete is implemented and so, on.
I leave it to the designer of the class and
this delete of b if there is a function defined
by the name Delete, I will assume that that
gets done and list dot Print I will expect
it to print a, c and d.
So, what did we get?
The details of the implementation of append,
delete and creation of the list and so, on
are not exposed to the user of the class.
The main program became much cleaner.
See this.
This is much cleaner than making function
calls to append and checking whether this
is the first and second and so, on.
We didn't do any of that.
This becomes much cleaner here, and we trust
the implementation of the class List to be
correct and complete.
This is something that we get from the ah..
implementation of a class.

Hindi: 
रूप से जा सकते हैं
और कह सकते हैं कि
यदि हेरफेर हुआ है,
तो यह केवल इन विधियों
के माध्यम से हुआ
है और इन विधियों
में कुछ ऐसा है जो
गलत है।
और आप यह भी देखेंगे
कि आह .. यह आपको आंतरिक
प्रतिनिधित्व को
बदलने की अनुमति
देता है।
एक क्लास की धारणा
आपको आह .. आंतरिक
प्रतिनिधित्व को
बदलने की अनुमति
देती है।
यह कुछ ऐसा है जिसे
आप बहुत विस्तार
से देखेंगे आह .. एक
बाद की कक्षा में
जब हम विज्ञापन और
डेटा स्तृक्तुरेस(structures)
की धारणा के बारे
में बात करते हैं,
सही है।
तो, एक सूची के लिए
एक विज्ञापन के रूप
में, आंतरिक रूप से
एक लिंक सूची का उपयोग
कर सकता है या यह आंतरिक
रूप से एक अरराय का
उपयोग कर सकता है।
एक सूची की धारणा
सिर्फ तत्वों का
एक क्रम है।
मैं आंतरिक रूप से
किसी अरराय का उपयोग
कर सकता था या मैं
आंतरिक रूप से लिंक
सूची का उपयोग कर
सकता था।
इस तरह का कार्यान्वयन
विवरण किसी ऐसे व्यक्ति
से छिपाया जा सकता
है जो सिर्फ एक सूची
का उपयोग करना चाहता
है और यदि आप क्लाससेस
का उपयोग करते हैं
तो यह संभव है।
इसलिए, आह .. कई बार
हम जाते हैं और एक
अच्छा इंटरफ़ेस बनाते
हैं।
इसलिए, हम क्लाससेस(classes)
को इस तरह से परिभाषित
करते हैं कि एक इंटरफ़ेस
न्यूनतम है।
यह जितना संभव हो
उतना छोटा होना चाहिए,
एक ही समय में, इसे
पूरा करना होगा।
तो, यह छोटा होना है,
यह सभी बुनियादी
चीजों को करने के
लिए काफी छोटा है,
लेकिन इससे छोटा
नहीं है।
यह सबसे छोटी और सुरुचिपूर्ण
आह होनी चाहिए .. उन
चीजों का सेट जो आप
आंतरिक दुनिया के
लिए उजागर करना चाहते
हैं, आह .. बाहरी दुनिया
से मेरा मतलब है और
इसे सुरक्षित होना
है।
इसलिए, आप तर्क को
अलग तरीके से पारित
नहीं करना चाहते
हैं और इसलिए आप यह
सुनिश्चित करते हैं
कि यह सुरक्षित है।
इसलिए, आइए देखें
कि सी प्लस प्लस तरीके
से लिंकेड लिस्ट(linked
list) को कैसे परिभाषित
किया जाए।
यह वही है जो मैं पहले
वादा कर रहा था, ठीक
है।
तो, सी प्लस प्लस तरीके
से लिंकेड लिस्ट(linked
list) को परिभाषित करने
के लिए, आप ऐसा कुछ
करेंगे।
हम एक क्लास को परिभाषित
करते हैं जिसे नोड
कहा जाता है।
यह एक स्ट्रक्चर
के समान है, ठीक है।
इसलिए, हमारे पास
संरचनात्मक नोड डेटा
था और अगला, यहां हमारे
पास क्लास नोड है
जहां निजी सदस्य
डेटा और अगले हैं।
हम सार्वजनिक तरीके
भी प्रदान करते हैं।

Malayalam: 
പൂർത്തിയായി എന്ന്
ഞാൻ ഊഹിക്കുകയും
ലിസ്റ്റ് (list) പ്രിന്റ്
(print) ചെയ്യുകയും ചെയ്യും.
ഞങ്ങൾക്ക് എന്താണ്
ലഭിച്ചത്? ലിസ്റ്റ്
(list) കൂട്ടിച്ചേർക്കൽ,
ഇല്ലാതാക്കൽ, സൃഷ്ടിക്കൽ
തുടങ്ങിയവയുടെ വിശദാംശങ്ങൾ
ക്ലാസ് (class) ഉപയോക്താവിന്
വെളിപ്പെടുത്തില്ല.
മെയിൻ പ്രോഗ്രാം
(mai program) കൂടുതൽ വൃത്തിയായി.
കൂട്ടിച്ചേർക്കുന്നതിനായി
ഫംഗ്ഷൻ കോളുകൾ (function
call) വിളിക്കുന്നതിനേക്കാളും
ഇത് ഒന്നാമത്തേതും
രണ്ടാമത്തേതുമാണോയെന്ന്
പരിശോധിക്കുന്നതിനേക്കാളും
നല്ലതാണു ഇത്. ക്ലാസ്
ലിസ്റ്റ് (class list) നടപ്പിലാക്കുന്നത്
ശരിയാണെന്നും പൂർണ്ണമാണെന്നും
ഞങ്ങൾ വിശ്വസിക്കുന്നു.
തുടർന്നുള്ള ഡാറ്റാ
സ്ട്രക്ചർ (data structure)
പ്രഭാഷണങ്ങളിൽ ഞങ്ങൾ
സി പ്ലസ് പ്ലസ് (C++)
ഉപയോഗിക്കുന്നതിനുള്ള
കാരണം ഇതാണ്.
ഡാറ്റാ (data) ഘടനകളെക്കുറിച്ചുള്ള
പ്രഭാഷണങ്ങളിൽ, സി
പ്ലസ് പ്ലസിന്റെ
(C++) വാക്യഘടന നിങ്ങൾ
കാണും. നിങ്ങൾക്ക്
പ്രവർത്തിക്കാനോ
കൈകാര്യം ചെയ്യാനോ
പോകുന്ന വ്യക്തിഗത
അംഗങ്ങളുണ്ടെന്ന
കാര്യം ഓർക്കുക.
ഒന്നുകിൽ നിങ്ങൾ
അംഗങ്ങളുടെ മൂല്യങ്ങൾ
മാറ്റും, അല്ലെങ്കിൽ
നിങ്ങൾ അംഗങ്ങളുടെ

Hindi: 
सार्वजनिक तरीकों
को देखें।
आपके पास सेटडेटा
और सेटनेक्स्ट है
जो डेटा को और अगले
को बदलने देगा, और
हमारे पास डेटा है
और अगला जो प्राप्त
करेगा।
तो, ये दो विधियाँ
आपको मिलती हैं और
ये दो विधियाँ आपको
सही, नोड तक पहुँच
प्रदान करती हैं।
इसलिए, आपको इन दोनों
के साथ बदलने की अनुमति
है और आपको इन दोनों
का उपयोग करके पढ़ने
की अनुमति है।
और एक अन्य विधि है
जिसे नोड कहा जाता
है जो क्लास नोड के
लिए निर्माता है।
यह कुछ नहीं कर रहा
है।
तो, इसका कुछ भी नहीं
बदल रहा है।
तो, यह आह .. कुछ भी
स्थापित नहीं है।
तो, यह मूल क्लास है
और हम इस वर्ग को लिंकेड
लिस्ट(linked list) के अंदर
उपयोग करने जा रहे
हैं।
तो, लिंकेड लिस्ट(linked
list) में क्या है?
लिंकेड लिस्ट(linked
list) में पहला नोड है,
जिसे फ़र्स्ट नोड
कहा जाता है।
तो, लिंकेड लिस्ट(linked
list) में पहला नोड है
और यह प्रिंट, अपेंड,
डिलीट और इसी तरह
के विभिन्न ऑपरेशंस
को सपोर्ट करता है।
आह .. अगर मैं शुरू
में एक खाली सूची
चाहता हूं, तो यह करना
चाहिए कि यह सुनिश्चित
करने के लिए कोई वैध
नोड नहीं है।
तो, पहले यह शून्य
के बराबर होती है।
तो, अब, आप देख सकते
हैं कि लिंकेड लिस्ट(linked
list) की धारणा ज्यादा
साफ हो जाती है, सही।
इसलिए, यदि आप सूची
में कुछ भी हेरफेर
करना चाहते हैं, तो
आपको इन कार्यों
से गुजरना होगा; अपेंड,
डिलीट और प्रिंट।
आप सीधे नहीं जा सकते
हैं और सीधे पहुंच
सकते हैं क्योंकि
डिफ़ॉल्ट रूप से
पहला निजी है।
आप पहले सीधे पहुँच
नहीं सकते।
आप केवल प्रिंट, एपेंड
और डिलीट जैसे इंटरफ़ेस
फ़ंक्शन के माध्यम
से जा सकते हैं।
आइए देखें कि एक प्रिंट
विधि कैसी दिखती
है।
तो, प्रिंट का कार्यान्वयन
इस तरह दिखेगा।
तो, नोड स्टार टेम्प
पहले बराबर है।
यदि अस्थायी स्वयं
रिक्त है, जिसका अर्थ
है कि यह एक खाली सूची
है, तो आप स्क्रीन
पर खाली प्रिंट करना
चाह सकते हैं।
यदि टेम्प, सूची में
केवल एक नोड है, तो
पहले नोड का अगला,
शून्य होगा।
हम वास्तव में अगले
क्षेत्र का उपयोग
नहीं करते हैं, लेकिन
हम अगले टेम्प के
अगले नामक विधि को
कहते हैं।
यदि वह नल(null) हो जाता
है, तो उस चरित्र को
प्रिंट करें जो अस्थायी
डेटा में निहित है
और फिर, एरो नल द्वारा
पीछा किया जाता है।
अन्यथा हम डू वाइल(do
while) लूप करते समय करते
हैं जो एक बार में
एक वर्ण को प्रिंट
करता है और जिस तरह
से हम करते हैं वह
है, हम डेटा तत्व या
नोड्स के अगले पॉइंटर
को सीधे एक्सेस नहीं
करते हैं।

Malayalam: 
മൂല്യങ്ങൾ വായിക്കാൻ
പോകുന്നു. വ്യക്തിഗത
അംഗങ്ങളെ കൈകാര്യം
ചെയ്യാൻ ഉപയോഗിക്കുന്ന
പബ്ലിക് മെത്തേഡുകൾ
(public method) ഉണ്ട്. കൂടാതെ
പബ്ലിക് മെത്തേഡുകളാൽ
(public method) മാത്രം വിളിക്കപ്പെടുന്ന
പ്രൈവറ്റ് മെത്തേഡുകളും
(private method) നിങ്ങൾ കണ്ടേക്കാം,
ഡോട്ട് ഓപ്പറേറ്റർ
(dor operator) ഉപയോഗിച്ച്
മെത്തേഡുകൾ (method) പ്രയോഗിക്കുന്നത്
നിങ്ങൾ കാണും. ഉദാഹരണത്തിന്,
ലിങ്ക്ഡ് ലിസ്റ്റ്
(linked list) അപ്പെൻഡ് (append)
x.append ചെയ്യും. myBirthday.month.
നിങ്ങൾക്ക് ആവശ്യമുള്ളത്
സി പ്ലസ് പ്ലസിന്റെ
(C++) അടിസ്ഥാന വാക്യഘടനയാണ്,
അത് ആന്തരിക അംഗങ്ങളും
ആന്തരിക മെത്തേഡുകളും
ഉള്ള ക്ലാസുകളുണ്ടെന്ന്
(class) കാണിക്കുന്നു.
അവർക്ക് പബ്ലിക്
(public) അംഗങ്ങളും പബ്ലിക്
മെത്തേഡുകളും (public
method) ഉണ്ടായിരിക്കാം,
കൂടാതെ ഡോട്ട് ഓപ്പറേറ്റർ
(dot operator) ഉപയോഗിക്കുന്ന
സ്ട്രക്ച്ചറുകൾ
(structure) ചെയ്യുന്നതുപോലെ
മെമ്പറുകളും (member)
മെത്തേഡുകളും (method)
ഉപയോഗിക്കാം.
ഇതിനപ്പുറം നിങ്ങൾക്ക്
മിക്കവാറും സി പ്ലസ്
പ്ലസ് (C++) ആവശ്യമില്ല,

English: 
This is the reason why we use C plus plus
in the data structures lectures that are following.
So, in the lectures on data structures, you
will see syntax of C plus plus.
So, don't be bogged on by the syntax of C
plus plus.
Just remember that you have individual members
that are going to get operated on or manipulated.
You will you will either change the values
of the members, or you are going to read the
values of the members.
You will see that there are public methods
that are used to manipulate the individual
members, and you may also see private methods
which are only called by public methods, and
you will see that the methods are actually
invoked using the dot operator.
For example, the ah.. linked list append would
do myList dot append of x or you have myBirthday
dot month and so, on.
So, don't be surprised by functions being
called with the dot operator.
So, all you need is the basic syntax of C
plus plus which shows that there are classes

Malayalam: 
ഞാൻ നേരത്തെ സൂചിപ്പിച്ചതുപോലെ,
ഈ പ്രഭാഷണത്തിൽ ഇതിനേക്കാൾ
കൂടുതലായി ഞങ്ങൾ
ഒന്നും ചെയ്യാൻ പോകുന്നില്ല.
നിങ്ങൾക്ക് സി പ്ലസ്
പ്ലസ് (C++) ആവശ്യമുണ്ടെങ്കിൽ,
ഇത് യഥാർത്ഥത്തിൽ
നിങ്ങൾ ചെയ്യേണ്ട
ഒരു പുതിയ കോഴ്സാണ്,
അവിടെ നിങ്ങൾ സി
പ്ലസ് പ്ലസിന്റെ
(C++) വാക്യഘടനയും അർത്ഥവും
ഉപയോഗിച്ച് ആരംഭിക്കുകയും
ഒബ്ജക്റ്റ് ഓറിയന്റഡ്
ഡിസൈൻ (object oriented design) എങ്ങനെ
ചെയ്യാമെന്ന് മനസിലാക്കുകയും
ചെയ്യുക. ഈ കോഴ്സിന്റെ
ലക്ഷ്യം അടിസ്ഥാന
പ്രോഗ്രാമിംഗും
(programming) ഡാറ്റ (data) ഘടനകളും
അൽഗോരിതങ്ങളും (algorithm)
ആണ്; കൂടുതൽ വിശദമായി
ഞങ്ങൾ സി പ്ലസ് പ്ലസ്
(C++) സ്പർശിക്കില്ല.

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

English: 
which has internal members and internal methods.
And they may have public members and public
methods, and the members and methods are going
to be used just like you do it for structures
using the dot operator..
So, beyond this you probably don't need much
of C plus plus and as I mentioned earlier,
we are not going to do anything more than
that in this lecture.
So, I said this is not a completely justified
introduction to C plus plus.
I have did I have done just enough so, that
you can appreciate the slides that are following
or the lectures that are following on data
structures.
So, if you need C plus plus, this is actually
a completely new course that you have to do,
where you start with the syntax and semantics
of C plus plus and also, understand how to
do object oriented design.
Since, this course's objective is basic programming
and data structures and algorithms; we will
not touch up on C plus plus in any further
detail.
So, thank you and this brings me to the end
of this lecture.

Hindi: 
डेटा प्रकार सूची
में से एक है और यह
संलग्न करें a, b, c और
d इन वर्णों को a, b और
c और d सूची में जोड़ने
जा रहा है।
देखते हैं कि स्यंताक्ष
कैसी है।
तो, लिस्ट एक ऑब्जेक्ट
है।
जब मैं ऑब्जेक्ट
डॉट अपेंड कहता हूं,
तो यह ऑब्जेक्ट डेटा
टाइप लिस्ट का होता
है।
तो, यह पता लगाने के
लिए जा रहा है कि क्या
एपेंड नाम से कोई
विधि है; और यह क्या
लेता है परिशिष्ट
कि आह .. डेटा प्रकार
कैरक्टर(character) लेता
है।
तो, हम एक कैरक्टर(character)
पास कर रहे हैं और
लिस्ट डॉट अपेंड
आह .. सूची में एक जोड़
देगा।
इस समय, यह सूची खाली
है।
हमें इस बारे में
चिंता करने की जरूरत
नहीं है।
हमने केवल एक बार
की सूची डॉट अपेंड,
और पहली बार आह कहा
था .. अपेंडेड कहा
जाता है, यहां अंदर
आप एक नोड बनाएंगे।
यह सच नहीं होगा।
आप पहले पॉइंटर को
न्यूनोडे में बदल
देंगे और शायद हम
इसे प्रिंट भी कर
सकते हैं।
जैसे ही आप आह .. एक
नोड के साथ सूची बनाते
हैं, आप इसे प्रिंट
कर सकते हैं और फिर,
हम बी के लिस्ट डॉट
एपेंड करते हैं।
इस बिंदु पर सूची
में पहले से ही a है,
और आह शामिल है .. अब
विधि इस पर गौर करेगी
पहले नोड नहीं है।
तो, यह सूची के माध्यम
से जाएगा, यह पता लगाएं
कि आह .. अशक्त से क्या
इंगित किया गया है।
उस बिंदु पर, यह इसे
जोड़ देगा।
तो, अब a बी को इंगित
करेगा।
यदि आप ऐसा करते हैं,
तो b, c को इंगित करता
है और जब आप प्रिंट
करते हैं, तो आप पहले
पॉइंटर से शुरू करते
हैं, प्रिंट(Print) a, प्रिंट(print)
b,प्रिंट(print)c और ऐसे
ही प्रिंट किए जाते
हैं, और अंत में जाते
हैं।
अब, आप डी संलग्न कर
सकते हैं।
तो, लिस्ट में a, b, c,
d और अंत में होगा,
यदि आप कॉल लिस्ट
डॉट डिलीट ऑफ बी करते
हैं, अगर डिलीट नाम
से कोई फंक्शन कार्यान्वित
होता है, तो हम मानते
हैं कि आह .. प्रोग्रामर
ने पहले ही इस बात
का ध्यान रखा है।
क्लास के डिज़ाइनर
ने प्रिंट अपपेंड
और डिलीट(print append and delete)
का ध्यान रखा है।
क्लास के उपयोगकर्ता
के रूप में।
इसलिए, जब मैंने कहा
कि उपयोगकर्ता और
प्रोग्रामर और इसलिए,
अब तक मैं कक्षा के
उपयोगकर्ता के बारे
में बात कर रहा हूं,
ठीक है।
इसलिए, क्लास का उपयोगकर्ता,
इसलिए एक उपयोगकर्ता
के रूप में मैं लिंकेड
लिस्ट चाहता हूं।
मैं इस बारे में चिंता
नहीं करना चाहता
कि सूची किस प्रकार
से है .. कार्यान्वित
की गई, एपेंड को कैसे
लागू किया गया; हटाने
को लागू किया जाता
है और इसी तरह, इस
पर।

Hindi: 
मैं इसे कक्षा के
डिज़ाइनर के पास
छोड़ता हूँ और b का
यह डिलीट अगर कोई
फ़ंक्शन है जिसे
डिलीट नाम से परिभाषित
किया गया है, तो मैं
मान लूंगा कि यह हो
जाता है और लिस्ट
डॉट प्रिंट मैं उम्मीद
करता हूँ कि यह a, c
और d प्रिंट करेगा।
तो, हमें क्या मिला?
क्लास(class) के उपयोगकर्ता
के लिए एपेंड के कार्यान्वयन,
सूची को हटाने और
बनाने का विवरण और,
इस तरह से उजागर नहीं
किया गया है।
मुख्य कार्यक्रम
बहुत साफ हो गया।
यह देखो।
यह अपपेंड को फ़ंक्शन
कॉल करने और जाँचने
की तुलना में बहुत
साफ है कि क्या यह
पहला और दूसरा है
और इसी तरह।
हमने ऐसा कुछ नहीं
किया।
यह यहां बहुत साफ
हो जाता है, और हम
सही और पूर्ण होने
के लिए क्लास(class) सूची
के कार्यान्वयन पर
भरोसा करते हैं।
यह एक ऐसी चीज है जो
हमें आह .. एक क्लास(class)
के कार्यान्वयन से
मिलती है।
यही कारण है कि हम
डेटा स्तृक्तुरेस(structures)
के व्याख्यान में
सी प्लस प्लस का उपयोग
कर रहे हैं जो निम्नलिखित
हैं।
इसलिए, डेटा स्तृक्तुरेस(structures)
पर व्याख्यान में,
आपको सी प्लस प्लस
का सिंटैक्स दिखाई
देगा।
तो, सी प्लस प्लस के
सिंटैक्स द्वारा
पर काट नहीं किया
जाना चाहिए।
बस याद रखें कि आपके
पास अलग-अलग सदस्य
हैं जो संचालित या
हेरफेर करने वाले
हैं।
आप करेंगे या तो सदस्यों
के मूल्यों को बदल
देंगे, या आप सदस्यों
के मूल्यों को पढ़ने
जा रहे हैं।
आप देखेंगे कि सार्वजनिक
तरीके हैं जो व्यक्तिगत
सदस्यों को हेरफेर
करने के लिए उपयोग
किए जाते हैं, और आप
निजी तरीकों को भी
देख सकते हैं, जिन्हें
केवल सार्वजनिक विधियों
द्वारा बुलाया जाता
है, और आप देखेंगे
कि वास्तव में डॉट
ऑपरेटर का उपयोग
करके तरीकों को लागू
किया जाता है।
उदाहरण के लिए, आह
.. लिंक की गई सूची
परिशिष्ट x के myList डॉट
एपेंड करेगा या आपके
पास myBirthday डॉट महीने
और इसी तरह, पर होगा।
इसलिए, डॉट ऑपरेटर
के साथ कॉल किए जा
रहे कार्यों से आश्चर्यचकित
न हों।
तो, आप सभी की जरूरत
है सी प्लस प्लस का
मूल सिंटैक्स है
जो दिखाता है कि ऐसी
क्लाससेस हैं जिनमें
आंतरिक सदस्य और
आंतरिक तरीके हैं।
और उनके पास सार्वजनिक
सदस्य और सार्वजनिक
तरीके हो सकते हैं,
और सदस्यों और विधियों
का उपयोग उसी तरह
किया जा रहा है जैसे
आप इसे डॉट ऑपरेटर
का उपयोग करके स्तृक्तुरेस(structures)
के लिए करते हैं।
इसलिए, इससे परे आपको
शायद सी प्लस प्लस
और के रूप में बहुत
अधिक आवश्यकता नहीं
है।
मैंने पहले उल्लेख
किया था, हम इस व्याख्यान

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