#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
    // 속성 (멤버 변수)
    string name;
    int age;

    // 기능 (멤버 함수)
    void bark() {
        cout << name << "이(가) 짖습니다! 멍멍!" << endl;
    }
};

class Cat {
private:
    string name;  // 외부에서 직접 접근 불가

public:
    void setName(string n) {
        name = n;
    }

    void meow() {
        cout << name << "이(가) 야옹!" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.name = "워윅";
    myDog.age = 5;

    myDog.bark();

    Cat myCat;
    myCat.setName("유미");

    myCat.meow();

    return 0;
}

간단한 class 사용 예시

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char v4; // [rsp+7h] [rbp-89h] BYREF
  char *v5; // [rsp+8h] [rbp-88h]
  _BYTE v6[32]; // [rsp+10h] [rbp-80h] BYREF
  _BYTE v7[32]; // [rsp+30h] [rbp-60h] BYREF
  _BYTE v8[32]; // [rsp+50h] [rbp-40h] BYREF
  int v9; // [rsp+70h] [rbp-20h]
  unsigned __int64 v10; // [rsp+78h] [rbp-18h]

  v10 = __readfsqword(0x28u);
  Dog::Dog((Dog *)v8);
  std::string::operator=(v8, &unk_3038);
  v9 = 5;
  Dog::bark((Dog *)v8);
  Cat::Cat((Cat *)v6);
  v5 = &v4;
  std::string::basic_string<std::allocator<char>>(v7, &unk_303F, &v4);
  Cat::setName(v6, v7);
  std::string::~string(v7);
  std::__new_allocator<char>::~__new_allocator(&v4);
  Cat::meow((Cat *)v6);
  Cat::~Cat((Cat *)v6);
  Dog::~Dog((Dog *)v8);
  return 0;
}

IDA 디컴파일 코드는 이런 느낌.

class가 따로 정의되진않고 구조체처럼 변수가 정의되고, 함수가 구조체이름:: 구조로 되어있음.

또 다른 예시

#include <iostream>
using namespace std;

class Rectangle {
private:
    int width;
    int height;

public:
    // 생성자
    Rectangle(int w, int h) {
        width = w;
        height = h;
    }

    // 넓이 계산 함수
    int area() {
        return width * height;
    }

    // 디버깅용: 정보 출력 함수
    void print() {
        cout << "Width: " << width << ", Height: " << height << endl;
    }
};

int main() {
    int w, h;
    cin >> w >> h;
    Rectangle r(w, h);  // 가로 3, 세로 4인 사각형 생성

    r.print();                    // 변수 확인
    cout << "넓이: " << r.area() << endl;  // 넓이 출력

    return 0;
}

void __fastcall sub_1290(_DWORD *a1, int a2, int a3)
{
  *a1 = a2;
  a1[1] = a3;
}

void __fastcall sub_12D6(unsigned int *a1)
{
  __int64 v1; // rax
  __int64 v2; // rax
  __int64 v3; // rax
  __int64 v4; // rax

  v1 = std::operator<<<std::char_traits<char>>(&std::cout, "Width: ");
  v2 = std::ostream::operator<<(v1, *a1);
  v3 = std::operator<<<std::char_traits<char>>(v2, ", Height: ");
  v4 = std::ostream::operator<<(v3, a1[1]);
  std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
}

__int64 __fastcall sub_12B8(_DWORD *a1)
{
  return (unsigned int)(*a1 * a1[1]);
}

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  __int64 v3; // rax
  __int64 v4; // rbx
  unsigned int v5; // eax
  __int64 v6; // rax
  int a2a; // [rsp+8h] [rbp-28h] BYREF
  int a3a; // [rsp+Ch] [rbp-24h] BYREF
  _DWORD a1a[2]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v11; // [rsp+18h] [rbp-18h]

  v11 = __readfsqword(0x28u);
  v3 = std::istream::operator>>(&std::cin, &a2a, a3);
  std::istream::operator>>(v3, &a3a, v3);
  sub_1290(a1a, a2a, a3a);
  sub_12D6(a1a);
  v4 = std::operator<<<std::char_traits<char>>(&std::cout, &unk_2017);
  v5 = sub_12B8(a1a);
  v6 = std::ostream::operator<<(v4, v5);
  std::ostream::operator<<(v6, &std::endl<char,std::char_traits<char>>);
  return 0;
}

result로 이상하게 리턴하는 함수는 void로 바꾸는 게 분석에 용이하다.