1️⃣ What is the socket structure?
2️⃣ Why is it not designed as a C++ class?

Let’s go step-by-step.

1️⃣ What actually happens when you call socket()

int server_fd = socket(AF_INET, SOCK_STREAM, 0);

This does not create a C++ object.

Instead it asks the Linux kernel to create a socket.

Internally the kernel creates something like this (simplified):

struct socket
{
    int type;          // TCP / UDP
    int state;         // listening / connected
    int protocol;      // IPPROTO_TCP
    struct sock *sk;   // internal networking data
};

But this structure lives inside the Linux kernel, not inside your program.

Your program cannot see this structure directly.

2️⃣ Why do we only get an int?

Because Linux uses a file descriptor system.

Example:

int server_fd = socket(...);

server_fd might be:

3

This 3 is just an index into a kernel table.

Example kernel table:

Process File Descriptor TableFD   Resource
----------------
0    stdin
1    stdout
2    stderr
3    socket
4    file
5    pipe

So 3 points to the socket object inside the kernel.

3️⃣ Why Linux designed it this way

Linux treats everything as a file.

Examples:

ResourceAccess method
Fileread/write
Socketread/write
Piperead/write
Deviceread/write

So sockets use the same interface.

Example:

read(server_fd, buffer, 1024);
write(server_fd, data, size);
close(server_fd);

This works because sockets behave like files.

4️⃣ Why not a C++ class?

Because the network API was created before C++ existed.

Sockets came from Unix in 1983 (Berkeley sockets).

At that time:

Language = C
C++ did not exist yet

So the API was designed like:

int socket();
int bind();
int listen();
int accept();

Later C++ programs just reuse the C API.

5️⃣ How C++ programmers usually handle it

In modern C++, people wrap sockets inside classes.

Example:

class Socket
{
    int fd;public:
    Socket()
    {
        fd = socket(AF_INET, SOCK_STREAM, 0);
    }    ~Socket()
    {
        close(fd);
    }    int get_fd()
    {
        return fd;
    }
};

Usage:

Socket server;

This is a C++ wrapper over the C socket API.

Libraries like these already exist:

  • Boost.Asio
  • Poco
  • Qt Network

6️⃣ Real architecture

Your C++ program
        |
        | socket()
        v
---------------------
 Linux System Call
---------------------
        |
        v
 Linux Kernel
   socket struct
        |
        v
 Network stack
(TCP/IP implementation)

Your program only holds a reference (file descriptor).

7️⃣ Example of internal flow

When your server runs:

int server_fd = socket(AF_INET, SOCK_STREAM, 0);

Kernel:

Create socket object
Allocate FD = 3
Return 3

Then:

bind(3, ...)
listen(3, ...)
accept(3, ...)

All operations reference FD 3.

8️⃣ Why this design is powerful

Because everything is unified.

Example:

read(fd, buffer, 1024);

This works for:

  • files
  • sockets
  • pipes
  • devices

This makes Unix extremely flexible.

✅ Simple answer

sock​et() is not a C++ class because:

  1. It was designed in C (Unix BSD sockets)
  2. The actual socket object exists inside the kernel
  3. Your program only receives a file descriptor integer