이런! 당신은 알고 계십니까?

대학 초창기에 C++를 배울 때 OOPS의 개념이 정확히 무엇을 의미하는지 이해하는 데 많은 혼란에 직면했습니다.
저는 초보자 수준의 실수를 많이 저질렀고 그로부터 배웠습니다. 시간이 지남에 따라 OOPS는 C++ 언어에서 내가 가장 좋아하는 개념이 되었습니다.

여기서는 OOPS의 중요한 개념 중 일부를 살펴보겠습니다.



OOPS의 기초로 들어가기 전에 클래스와 객체가 무엇인지 아는 것이 중요합니다.

수업:
멤버 함수와 다른 데이터 변수가 있는 사용자 정의 데이터 유형입니다. 메모리는 객체가 정의된 경우에만 클래스에 할당됩니다.

물체:
클래스의 인스턴스입니다. 간단히 말해서 클래스의 청사진입니다.

// header files 
class Class_name
{ 
/*
Access specifier 
public variables: can be accessed from everywhere
protected variables: can be accessed by the classes of the same package
private variables: can be accessed within the same class only.
->This is helpful when you learn the concept of Abstraction in OOPS. 
*/
public: 

// data variables
int variable_A;

// member functions
void print_function() 
{ 
cout << "Value of variable is :" << variable_A; 
} 
}; 

main() { 

// declaring object <Syntax: Class_name object_name>
Class_name object;  

/*accessing the variables in class and assigning value to it via object*/
object.variable_A= 20;  

// accessing member function in class 
object.print_function(); 

} 

이제 OOPS의 네 가지 주요 개념을 다룰 것입니다.

캡슐화 및 추상화:

간단히 말해서 캡슐화는 데이터를 패키지에 숨기는 것을 의미합니다. 필수 정보만 표시하고 클라이언트/사용자에게 불필요한 세부 정보를 숨기는 추상화.

전체 클래스를 정의할 별도의 헤더 파일을 만듭니다. 그런 다음 기본 함수의 개체를 사용하여 클래스의 구성 요소에 액세스할 수 있습니다.

// header file header.h 
#include <iostream>
using namespace std ;
// we are defining a class in our header file
class Classtwo
{
private:  // for data abstraction
int var = 5; 
public :
int functionOne(); // declaring functionOne inside class
};
int Classtwo::functionOne() // defining functionOne outside class
{
cout << "functionOne is called(in header file)\n";
}

//main.cpp
// other header files
#include "header.h"
// namespace...

main(){
/* class Classtwo is in header file*/
Classtwo objectOne;
objectOne.functionOne(); 
cout<< objectOne.var; // would output the value of var 
}

상속:

간단히 말해서 파생 클래스는 기본 클래스에서 속성을 상속합니다.

//header files 
class Base // parent class
{
public :
int number =5;
};
class Derived: public Base // child class 
{
public :
void printFunction()
{
cout<<"Hello World";
}
};

main(){
Derived obj; /*object of 'Derived' class can access public components of 'Base ' class*/

cout<< obj.number ; 
//would output the number which is in Base class

다형성:

한마디로 형태가 다르다는 뜻이다. 다형성에는 두 가지 유형이 있습니다.

-> 런타임 다형성:

프로그램에서 함수를 재정의할 때 발생합니다.

// header files 

class Virtual_one
{
public :
int fun_One()
{
cout<<"fun_One works in v1\n";
}
};
class Virtual_two : public Virtual_one 
{
public :
int fun_One()
{
cout<<"fun_One works in v2\n";
}
virtual int fun_() 
// 'virtual' is used for late binding and runtime polymorphism.
{
cout<<"fun_ works in v2\n";
}
};
class Virtual_three : public Virtual_two // inheritance
{
int fun_()
{
cout<<"fun_works in v3\n";
}
};

main()
{
Virtual_one objA;
Virtual_two objBA , *objBB = new Virtual_two(); 
/*defining pointer object BB*/

Virtual_three objC;
objBB = &objC; 
/*objBB pointer of Virtual_two carries address of objC*/

objA.fun_One();
/*fun_One of Virtual_one would be accessed as objA is of that class*/

objBA.fun_One();
/*fun_One of Virtual_two would be accessed as objBA is of that class*/

objBB->fun_(); 
/*fun_ function is in Virtual_two and Virtual_three classes, we have used 'virtual' keyword for this*/

/* Note:
HERE objBB pointer(of Virtual_two class) carries address of objC(of Virtual_three class). So in objBB->fun_(); The fun_() of Virtual_two class would be working, as objBB pointer belongs to that class.
But when you add the keyword 'virtual' : The fun_() of Virtual_three class would work. */

-> 컴파일 타임 다형성:

프로그램에서 함수나 연산자를 오버로드할 때 발생합니다.

연산자 오버로딩의 경우를 고려하십시오.

// header files
class Op_ovrload 
{
int numberA;
int numberB ;
public :
int inputNum()
{
cin >> numberA >> numberB ; 
/*writing cin statements in class/header file is considered a bad practice though here it's just for simplicity of code*/
}

//  Without Overloading
Op_ovrload addTheSet(Op_ovrload tempObj)
{
Op_ovrload takeT_Obj ;

takeT_Obj.numberA = numberA + tempObj.numberA;
takeT_Obj.numberB = numberB + tempObj.numberB;

return takeT_Obj;
}

// With Overloading
Op_ovrload operator + (Op_ovrload tempObj) 
{ 
// tempObj is loaded as objB
Op_ovrload takeT_Obj ;

takeT_Obj.numberA= numberA + tempObj.numberA
takeT_Obj.numberB = numberB + tempObj.numberB;

return takeT_Obj;
}
};

main()
{
Op_ovrload objA ,objB , objC , objD;
// we would load values in objA and objB
objA.inputNum();
objB.inputNum();

objC = objA.addTheSet(objB);
objD = objA + objB;
/*objC and objD would output the same value. Here '+' has been overloaded*/
}

함수 오버로딩의 다른 경우를 고려하십시오.

// header files 

void printFun(int number) { 
  cout << " Value is" << number; 
} 
void printFun(double  num) { 
  cout << "Value is " << num; 
} 
/*Hence we can see the function is overloaded.
The same name of functions with different parameters passed. */

main() 
{ 
printFun(320); 
printFun(48.95); 
}

이것으로 기본 개념에 대한 설명을 마칩니다.

이 기사가 도움이 되었기를 바랍니다.