এই অধ্যায়টি ক্লাস এবং অবজেক্টের পরিচয় দেয়। বেশ কিছু গুরুত্বপূর্ণ
টি বিষয় কভার করা হয়েছে যা C++ প্রোগ্রামিং এর কার্যত সমস্ত দিকগুলির
সাথে সম্পর্কিত, তাই সাবধানে পড়ার পরামর্শ দেওয়া হয়।
এগিয়ে যাওয়ার আগে, আপনি নিম্নলিখিত প্রশ্নের সঠিক উত্তর দিতে
এবং অনুশীলনগুলি করতে সক্ষম হবেন।
1. এমন একটি প্রোগ্রাম লিখুন যা C++-স্টাইল I/O ব্যবহার করে ব্যবহারকারীকে একটি স্ট্রিং এর জন্য প্রম্পট করে এবং তারপর তার দৈর্ঘ্য প্রদর্শন করে।
2. নাম এবং ঠিকানার তথ্য ধারণ করে এমন একটি ক্লাস তৈরি করুন।
অক্ষর স্ট্রিংগুলিতে তথ্য সংরক্ষণ করুন যা ক্লাসের ব্যক্তিগত সদস্য।
একটি সর্বজনীন ফাংশন অন্তর্ভুক্ত করুন যা নাম এবং cla ঠিকানা সংরক্ষণ করে।
এছাড়াও একটি সর্বজনীন ফাংশন অন্তর্ভুক্ত করুন যা নাম এবং ঠিকানা প্রদর্শন করে।
(এই ফাংশনগুলিকে কল করুন স্টোর() এবং প্রদর্শন())
3. একটি ওভারলোডেড rotate() ফাংশন তৈরি করুন যা তার আর্গুমেন্টে
বিটগুলিকে বাম-ঘোরায় এবং ফলাফল প্রদান করে। এটি ওভারলোড যাতে
এটি ints এবং longs গ্রহণ করে। (একটি ঘূর্ণন একটি শিফটের মতোই হয়
তবে এক প্রান্ত থেকে সরানো বিটটি অন্য প্রান্তে স্থানান্তরিত হয়।)
4. নিম্নলিখিত খণ্ডের সাথে ভুল কি?
#include <iostream> using namespace std;
class myclass {
int i;
public:
.
.
.
};
int main()
{
myclass ob;
ob.i =10;
.
.
.
}
কনস্ট্রাক্টর এবং ডিস্ট্রাক্টর ফাংশন
আপনি যদি অনেক দিন ধরে প্রোগ্রাম লিখছেন, আপনি জানেন যে আপনার
প্রোগ্রামের অংশগুলির জন্য প্রাথমিককরণের প্রয়োজন হয়। আপনি যখন
বস্তুর সাথে কাজ করছেন তখন আরম্ভ করার প্রয়োজন আরও বেশি সাধারণ। প্রকৃতপক্ষে,
যখন বাস্তব সমস্যায় প্রয়োগ করা হয়, কার্যত আপনার তৈরি করা প্রতিটি বস্তুর জন্য
কিছু ধরণের আরম্ভের প্রয়োজন হবে। এই পরিস্থিতি মোকাবেলা করার জন্য, C++ একটি
কনস্ট্রাক্টর ফাংশনকে একটি শ্রেণি ঘোষণায় অন্তর্ভুক্ত করার অনুমতি দেয়। একটি ক্লাসের
কনস্ট্রাক্টর বলা হয় প্রতিবার যখন সেই ক্লাসের একটি অবজেক্ট তৈরি করা হয়। এইভাবে,
যেকোন সূচনা যা একটি অবজেক্টে সঞ্চালিত করা প্রয়োজন তা কনস্ট্রাক্টর ফাংশন দ্বারা
স্বয়ংক্রিয়ভাবে করা যেতে পারে। একটি কনস্ট্রাক্টর ফাংশন ক্লাসের একই নাম রয়েছে যার
এটি একটি অংশ এবং কোন রিটার্ন টাইপ নেই। উদাহরণস্বরূপ, এখানে একটি ছোট ক্লাস যে
একটি কনস্ট্রাক্টর ফাংশন রয়েছে:
#include <iostream> using namespace std;
class myclass {
int a;
public:
myclass(); // constructor
void show(); );
myclass::myclass ()
}
cout <<< "In constructor\n";
a = 10;
void myclass::show()
{
cout << a;
}
int main()
{
myclass ob;
ob.show();
return 0;
}
এই সাধারণ উদাহরণে, a-এর মান কনস্ট্রাক্টর myclass() দ্বারা আরম্ভ করা হয়।
অবজেক্ট ob তৈরি হলে কনস্ট্রাক্টর বলা হয়। একটি বস্তু তৈরি হয় যখন সেই বস্তুর
ঘোষণা বিবৃতি কার্যকর করা হয়। এটা বোঝা গুরুত্বপূর্ণ যে C++ এ, একটি পরিবর্তনশীল
ঘোষণা বিবৃতি হল একটি "অ্যাকশন স্টেটমেন্ট।" আপনি যখন সি-তে প্রোগ্রামিং করছেন,
তখন ঘোষণার বিবৃতিগুলিকে মনে করা সহজ সহজভাবে ভেরিয়েবল স্থাপন. যাইহোক,
C++ এ, যেহেতু একটি বস্তুর একটি কনস্ট্রাক্টর থাকতে পারে, একটি পরিবর্তনশীল ঘোষণা
বিবৃতি প্রকৃতপক্ষে, যথেষ্ট সংখ্যক ক্রিয়া ঘটতে পারে। লক্ষ্য করুন কিভাবে myclass()
সংজ্ঞায়িত করা হয়েছে। যেমন বলা হয়েছে, এর কোনো রিটার্ন টাইপ নেই।
C++ ফর্মাল সিনট্যাক্স নিয়ম অনুযায়ী, কনস্ট্রাকটোর জন্য রিটার্ন টাইপ থাকা বেআইনি।
গ্লোবাল অবজেক্টের জন্য, একটি অবজেক্টের কনস্ট্রাক্টরকে একবার বলা হয়,
যখন প্রোগ্রামটি প্রথম এক্সিকিউশন শুরু করে। স্থানীয় বস্তুর জন্য, কনস্ট্রাক্টর হয়
প্রতিবার ঘোষণার বিবৃতি কার্যকর করার সময় বলা হয়। কনস্ট্রাক্টরের পরিপূরক হল ধ্বংসকারী।
একটি বস্তু ধ্বংস হলে এই ফাংশন বলা হয়. আপনি যখন সঙ্গে কাজ করছেন
অবজেক্ট, যখন একটি বস্তু ধ্বংস হয়ে যায় তখন কিছু ক্রিয়া সম্পাদন করতে হয়।
উদাহরণস্বরূপ, একটি বস্তু যে মেমরি ঘেঁষা বরাদ্দ করে এটি তৈরি করা হয় যখন
এটি ধ্বংস হয়ে যায় তখন সেই মেমরিটি মুক্ত করতে চায়। একটি ধ্বংসকারীর নাম হল তার শ্রেণীর নাম, যার পূর্বে a~।
উদাহরণস্বরূপ এই ক্লাসে একটি ধ্বংসকারী ফাংশন রয়েছে:
#include <iostream> using namespace std;
class myclass {
int a;
public:
myclass(); // constructor
~myclass(); // destructor
void show();
};
myclass::myclass ()
{
cout << "In constructor\n";
a = 10;
}
myclass::~myclass()
{
cout << "Destructing...\n";
}
void myclass::show()
{
cout << a <<< "\n";
}
int main()
{
myclass ob;
ob.show();
return 0;
}
একটি বর্গ ধ্বংসকারী বলা হয় যখন একটি বস্তু ধ্বংস হয়.
স্থানীয় বস্তুগুলি সুযোগের বাইরে গেলে ধ্বংস হয়ে যায়।
প্রোগ্রাম শেষ হলে গ্লোবাল অবজেক্টগুলি ধ্বংস হয়ে যায়।
কনস্ট্রাক্টর বা ডেস্ট্রাক্টরের ঠিকানা নেওয়া সম্ভব নয়।
টেকনিক্যালি, একজন কনস্ট্রাক্টর বা ডেস্ট্রাক্টর যেকোনো
ধরনের অপারেশন করতে পারে। এই ফাংশনের মধ্যে কোডটি
যে class জন্য সংজ্ঞায়িত করা হয়েছে তার সাথে সম্পর্কিত কিছু
শুরু বা রিসেট করতে হবে না। উদাহরণস্বরূপ, পূর্ববর্তী উদাহরণগুলি
জন্য একজন কন্সট্রাক্টর 100টি জায়গায় পাই গণনা করতে পারে।
যাইহোক, একটি কনস্ট্রাক্টর বা ডেস্ট্রাক্টর থাকা একটি বস্তুর প্রারম্ভিকতা
বা সুশৃঙ্খলভাবে ধ্বংসের সাথে সরাসরি সম্পর্কিত নয় এমন ক্রিয়াগুলি খুব
খারাপ প্রোগ্রামিং শৈলীর জন্য তৈরি করে এবং এড়ানো উচিত।
উদাহরণ
আপনার মনে রাখা উচিত যে অধ্যায়ে তৈরি স্ট্যাক ক্লাসে স্ট্যাক
ইনডেক্স সেট করার জন্য একটি প্রাথমিক ফাংশন প্রয়োজন
পরিবর্তনশীল এই ফাংশন সঞ্চালনের জন্য ডিজাইন করা হয়েছে.
এখানে স্ট্যাক ক্লাসের একটি উন্নত করা হয়েছে যা একটি স্ট্যাক
অবজেক্ট তৈরি করার সময় স্বয়ংক্রিয়ভাবে আরম্ভ করতে à কনস্ট্রাক্টর ব্যবহার করে:
#include <iostream> using namespace std;
#define SIZE 10
// Declare a stack class for characters.
class stack {
char stck(SIZE) // holds the stack
int tos; // index of top of stack
public:
stack(); // constructor
void push (char ch); // push character on stack
char pop(); // pop character from stack
};
// Initializ, the stack.
stack:: stack()
{
cout<<"Constructing a stack\n";
tos = 0;
}
// Bush a character.
void stack::push(char ch)
{
if(tos==SIZE) {
cout<<< "Stack is full\n";
stck [tos] = ch;
tos++;
return;
}
// Pop a character.
char stack::pop()
{
if (tos==0) {
cout << "Stack is empty\n";
return 0; // return null on empty stack
}
tos--;
return stck[tos];
}
int main()
{
// Create two stacks that are automatically initialized.
stack s1, 82;
int i;
s1.push('a');
s2.push('x');
s1.push('b');
s2.push('y');
s1.push('c');
s2.push('z');
for(i=0; i<3; i++) cout << "Pop s1: << s1.pop() << "\n";
for(i=0; i<3; i++) cout << "Pop s2: " << s2.pop() << "\n";
return 0;
}
আপনি দেখতে পাচ্ছেন, এখন আরম্ভ করার কাজটি a এর পরিবর্তে কনস্ট্রাক্টর
ফাংশন দ্বারা স্বয়ংক্রিয়ভাবে সঞ্চালিত হয় পৃথক ফাংশন যা স্পষ্টভাবে প্রোগ্রাম
দ্বারা কল করা আবশ্যক। এটি একটি গুরুত্বপূর্ণ পয়েন্ট। যখন একটি সূচনা সঞ্চালিত হয়
স্বয়ংক্রিয়ভাবে যখন একটি বস্তু তৈরি করা হয়, এটি এমন কোনো সম্ভাবনাকে বাদ দেয় যে,
ত্রুটি দ্বারা, আরম্ভ করা হবে না। এটি আরেকটি উপায় যা বস্তুগুলি প্রোগ্রামের জটিলতা
কমাতে সাহায্য করে। আপনাকে, প্রোগ্রামার হিসাবে, আরম্ভ করার বিষয়ে চিন্তা করতে হবে না-
বস্তুটি আনা হলে এটি স্বয়ংক্রিয়ভাবে সঞ্চালিত হয় অস্তিত্বে
2. এখানে একটি উদাহরণ যা একটি কন্সট্রাক্টর এবং একটি ধ্বংসকারী ফাংশন
উভয়ের প্রয়োজনীয়তা দেখায়। এটি একটি সাধারণ স্ট্রিং ক্লাস তৈরি করে, যাকে
স্ট্রটাইপ বলা হয়, যাতে একটি স্ট্রিং এবং এর দৈর্ঘ্য থাকে। যখন একটি স্ট্রাইপ
অবজেক্ট তৈরি করা হয়, তখন স্ট্রিং ধরে রাখার জন্য মেমরি বরাদ্দ করা হয় এবং
এর প্রাথমিক দৈর্ঘ্য 0 এ সেট করা হয়। যখন একটি স্ট্রটাইপ অবজেক্ট ধ্বংস হয়ে যায়,
তখন স্মৃতি প্রকাশ করা হয়।
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
#define SIZE 255
class strtype {
char *p;
int len;
public:
strtype(); // constructor
-strtype(); //destructor
void set (char *ptr);
void show();
};
// Initialize a string object.
strtype::strtype()
{
p = (char *)malloc(SIZE);
if (!p) {
cout << "Allocation error\n";
exit(1);
}
*p = '\0'; len = 0;
// Free memory when destroying string object.
strtype::~strtype() {
cout << "Freeing p\n";
free (p);
}
3. এখানে একটি বস্তুর কনস্ট্রাক্টর এবং ডেস্ট্রাক্টর ব্যবহার করার
একটি আকর্ষণীয় উপায় রয়েছে। এই প্রোগ্রামটি টাইমার ক্লাসের
একটি অবজেক্ট ব্যবহার করে টাইমার টাইমারের একটি অবজেক্ট
কখন তৈরি করা হয় এবং কখন এটি ধ্বংস করা হয় তার মধ্যে ব্যবধান নির্ধারণ করে।
যখন বস্তুর ধ্বংসকারী বলা হয়, অতিবাহিত সময় প্রদর্শিত হয়। আপনি একটি
প্রোগ্রামের সময়কাল বা একটি ব্লকের মধ্যে একটি ফাংশন ব্যয় করার সময়কালের
জন্য এই ধরনের একটি বস্তু ব্যবহার করতে পারেন। শুধু নিশ্চিত করুন যে বস্তুটি সুযোগের
বাইরে চলে যায় যেখানে আপনি সময় ব্যবধানটি শেষ করতে চান।
#include <iostream>
#include <ctime> using namespace std;
class timer {
clock_t start;
public:
timer(); // constructor
~timer(); // destructor
};
timer::timer()
{
start = clock();
}
timer::~timer ()
clock_t end;
end = clock();
cout <<"Elapsed time: << (end-start) / CLOCKS PER SEC << "\n";
int main()
(
timer ob;
char c;
// delay...
cout << "Press a key followed by ENTER: "; cin >> C;
return 0;
}
এই প্রোগ্রামটি স্ট্যান্ডার্ড লাইব্রেরি ফাংশন clock() ব্যবহার করে,
যা প্রোগ্রামটি চলা শুরু হওয়ার পর থেকে সংঘটিত ঘড়ি চক্রের সংখ্যা প্রদান করে।
এই মানটিকে CLOCKS_PER_SEC দ্বারা ভাগ করলে মানটিকে সেকেন্ডে রূপান্তরিত হয়।
অনুশীলন
1. আপনি অধ্যায় 1-এ একটি কন্সট্রাকটর দিয়ে এর ইনিশিয়ালাইজেশন ফাংশন
প্রতিস্থাপন করে অনুশীলন হিসাবে যে কিউ ক্লাসটি তৈরি করেছেন সেটি পুনরায় কাজ করুন।
2. স্টপওয়াচ নামে একটি ক্লাস তৈরি করুন যা একটি স্টপওয়াচকে অনুকরণ করে
অতিবাহিত সময়ের ট্র্যাক রাখে। প্রাথমিকভাবে অতিবাহিত সময় 0 এ সেট করতে
একটি কন্সট্রাক্টর ব্যবহার করুন। start() এবং stop() নামক দুটি সদস্য ফাংশন
প্রদান করুন যা যথাক্রমে টাইমার চালু এবং বন্ধ করে। শো() নামে একটি সদস্য
ফাংশন অন্তর্ভুক্ত করুন যা অতিবাহিত সময় প্রদর্শন করে। এছাড়াও, একটি স্টপওয়াচ
অবজেক্ট ধ্বংস হয়ে গেলে ডেস্ট্রক্টর ফাংশনটি স্বয়ংক্রিয়ভাবে অতিবাহিত সময় প্রদর্শন করে।
(সরল করার জন্য, সেকেন্ডে সময় রিপোর্ট করুন।)
3. নিম্নলিখিত খণ্ডে দেখানো কন্সট্রাক্টরের সাথে কি ভুল?
class sample {
double a, b, c;
public:
double sample();
// error, why?
}
Subscribe our YouTube channel
Follow our TikTok account
0 Comments