AlgoDaily - Networking in C++

Home > C++ for concepts > C++ for concepts > Networking in C++

Introduction to Networking in C++

Networking is a crucial aspect of many software applications, and being able to implement networking functionality in C++ is a valuable skill for any programmer. In this lesson, we will provide an overview of networking concepts in C++ and cover the basics of creating networked applications.

C++ provides a rich set of libraries and functions for networking, allowing developers to build robust and efficient networked applications. Whether you are working on a client-server application, a distributed system, or any other networked software, understanding the fundamentals of networking in C++ is essential.

Topics Covered in this Lesson

TCP/IP and UDP protocols
Sockets and socket programming
Client-server architecture
Sending and receiving data over a network
Error handling and exception handling in networking

To start exploring networking in C++, let's take a look at a simple example to create a basic networking application:

TEXT/X-C++SRC

1#include <iostream>
2
3int main() {
4  // Networking code here
5  std::cout << "Networking in C++" << std::endl;
6  return 0;
7}

In this example, we include the necessary header files and create a simple main function. Inside the main function, we can write the networking code specific to our application.

Before we dive deeper into networking concepts and implementation in C++, it is important to have a basic understanding of C++ programming and concepts such as functions, variables, and control flow. If you are new to C++, make sure to familiarize yourself with these fundamental concepts before diving into networking.

xxxxxxxxxx
 
#include <iostream>
​
int main() {
  // Networking code here
  std::cout << "Networking in C++" << std::endl;
  return 0;
}

Build your intuition. Fill in the missing part by typing it in.

Networking in C++ is the process of ___ between two or more computers over a network connection. In C++, this can be accomplished using __ and ___. A __ is a communication endpoint that allows computers to send and receive data over the network. And a ___ is a unique identifier that helps identify a specific machine on the network. Networking in C++ enables the development of distributed applications, client-server architectures, and many other networked software solutions.

Write the missing line below.

In networking, a socket is an endpoint for sending or receiving data across a computer network. It provides a connection-oriented and reliable communication channel between two applications running on different machines.

To create a socket in C++, you will need to use the socket() function from the <sys/socket.h> header. Here's an example of how to create a socket:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3
4int main() {
5  int sockfd;
6
7  // Create a socket
8  sockfd = socket(AF_INET, SOCK_STREAM, 0);
9
10  if (sockfd == -1) {
11    std::cout << "Failed to create socket" << std::endl;
12    return 1;
13  }
14
15  std::cout << "Socket created successfully" << std::endl;
16
17  return 0;
18}

In this example, we include the necessary header file <sys/socket.h> and define an integer variable sockfd to hold the socket descriptor. We then call the socket() function, passing in the address family (AF_INET) for IPv4, the socket type (SOCK_STREAM) for TCP, and the protocol value (0) to let the system choose the appropriate protocol.

If the socket() function returns a value of -1, it indicates that an error occurred during socket creation. Otherwise, the socket is created successfully, and we can proceed with further network operations.

Creating a socket is the first step in building networked applications. Understanding the fundamentals of socket creation in C++ is crucial for implementing various networking functionalities.

xxxxxxxxxx
 
#include <iostream>
#include <sys/socket.h>
​
int main() {
  int sockfd;
​
  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
​
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  std::cout << "Socket created successfully" << std::endl;
​
  return 0;
}

Let's test your knowledge. Fill in the missing part by typing it in.

To create a socket in C++, you will need to use the ___________() function from the <sys/socket.h> header. Here's an example of how to create a socket:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3
4int main() {
5  int sockfd;
6
7  // Create a socket
8  sockfd = _______;
9
10  if (sockfd == -1) {
11    std::cout << "Failed to create socket" << std::endl;
12    return 1;
13  }
14
15  std::cout << "Socket created successfully" << std::endl;
16
17  return 0;
18}

Write the missing line below.

When creating a network application, you often need to bind a socket to a specific address and port. Binding a socket means associating a network address and port with the socket so that it can listen for incoming connections or send data to a specific destination.

To bind a socket in C++, you will use the bind() function from the <sys/socket.h> header. Here's an example of how to bind a socket:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4
5int main() {
6  int sockfd;
7  struct sockaddr_in serverAddr;
8
9  // Create a socket
10  sockfd = socket(AF_INET, SOCK_STREAM, 0);
11
12  if (sockfd == -1) {
13    std::cout << "Failed to create socket" << std::endl;
14    return 1;
15  }
16
17  // Set up the server address
18  serverAddr.sin_family = AF_INET;
19  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
20  serverAddr.sin_port = htons(8080);
21
22  // Bind the socket
23  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
24
25  if (bindResult == -1) {
26    std::cout << "Failed to bind socket" << std::endl;
27    return 1;
28  }
29
30  std::cout << "Socket bound successfully" << std::endl;
31
32  return 0;
33}

In this example, we include the necessary header files <sys/socket.h> and <netinet/in.h>. We define an integer variable sockfd to hold the socket descriptor and a sockaddr_in struct variable serverAddr to hold the server address information.

We then call the socket() function to create a socket, specifying the address family (AF_INET) for IPv4 and the socket type (SOCK_STREAM) for TCP.

Next, we set up the server address by setting the sin_family field to AF_INET, the sin_addr.s_addr field to htonl(INADDR_ANY) to bind the socket to any available network interface, and the sin_port field to the desired port number.

Finally, we call the bind() function to bind the socket to the specified address and port. If the bind() function returns a value of -1, it indicates that an error occurred during socket binding.

Binding a socket is a crucial step in creating a networked application. It allows the application to listen for incoming connections or send data to a specific destination. Understanding how to bind a socket in C++ is essential for building networking functionalities for your applications.

Are you sure you're getting this? Click the correct answer from the options.

Which function is used to bind a socket in C++?

Click the option that best answers the question.

socket()
bind()
connect()
listen()

To make a socket listen for incoming connections, you need to perform a few steps:

Create a socket using the socket() function from the <sys/socket.h> header. You specify the address family as AF_INET, the socket type as SOCK_STREAM for TCP, and set the protocol as 0.
TEXT/X-C++SRC
```
1int sockfd;
2sockfd = socket(AF_INET, SOCK_STREAM, 0);
```
Set up the server address using the sockaddr_in structure. This structure contains fields such as sin_family for the address family, sin_addr.s_addr for the IP address, and sin_port for the port number. In this example, we set the sin_addr.s_addr to htonl(INADDR_ANY) to bind the socket to any available network interface, and we set the sin_port to the desired port number.
TEXT/X-C++SRC
```
1struct sockaddr_in serverAddr;
2serverAddr.sin_family = AF_INET;
3serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
4serverAddr.sin_port = htons(8080);
```
Bind the socket to the server address using the bind() function. This associates the socket with the specified address and port.
TEXT/X-C++SRC
```
1int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
```
Finally, you can make the socket listen for incoming connections using the listen() function. You pass the socket descriptor and specify the maximum number of connections that can be queued using the second parameter. In this example, we set the maximum queue size to 10.
TEXT/X-C++SRC
```
1int listenResult = listen(sockfd, 10);
```

If any errors occur during these steps, you can check the return values of the relevant functions to handle them accordingly.

Once the socket is listening for connections, you can then accept incoming connections using the accept() function. This allows you to establish a connection with a client and start sending and receiving data.

Remember to close the socket when you're done with it by calling the close() function!

Here's an example code that demonstrates how to make a socket listen for connections:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4
5int main() {
6  int sockfd;
7  struct sockaddr_in serverAddr;
8
9  // Create a socket
10  sockfd = socket(AF_INET, SOCK_STREAM, 0);
11
12  if (sockfd == -1) {
13    std::cout << "Failed to create socket" << std::endl;
14    return 1;
15  }
16
17  // Set up the server address
18  serverAddr.sin_family = AF_INET;
19  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
20  serverAddr.sin_port = htons(8080);
21
22  // Bind the socket
23  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
24
25  if (bindResult == -1) {
26    std::cout << "Failed to bind socket" << std::endl;
27    return 1;
28  }
29
30  // Listen for connections
31  int listenResult = listen(sockfd, 10);
32
33  if (listenResult == -1) {
34    std::cout << "Failed to listen for connections" << std::endl;
35    return 1;
36  }
37
38  std::cout << "Socket is now listening for connections" << std::endl;
39
40  return 0;
41}

xxxxxxxxxx
}
 
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
​
int main() {
  int sockfd;
  struct sockaddr_in serverAddr;
​
  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
​
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);
​
  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
​
  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }
​

Build your intuition. Is this statement true or false?

To make a socket listen for incoming connections, you need to call the listen() function after binding the socket.

Press true if you believe the statement is correct, or false otherwise.

To accept an incoming connection on a socket, you need to perform the following steps:

Create a new socket using the socket() function, just like in the previous step.
TEXT/X-C++SRC
```
1int sockfd, newSockfd;
2sockfd = socket(AF_INET, SOCK_STREAM, 0);
```
Set up the server address, as mentioned before.
Bind the socket to the server address, as mentioned before.
Make the socket listen for connections, as mentioned before.
Call the accept() function to accept an incoming connection. This function blocks until a connection is made. You pass the listening socket descriptor, the client address structure, and the length of the client address structure as parameters.
TEXT/X-C++SRC
```
1socklen_t clientAddrLen;
2newSockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
```

If the accept() function returns a valid socket descriptor, it means a connection has been successfully established.

TEXT/X-C++SRC

1if (newSockfd == -1) {
2  std::cout << "Failed to accept connection" << std::endl;
3  return 1;
4}
5
6std::cout << "Accepted connection from client" << std::endl;

Remember to handle any errors that might occur during the accept process and close both the listening socket and the new socket when you're done.

Here's an example code that demonstrates how to accept an incoming connection on a socket:

SNIPPET

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4
5int main() {
6  // ... code from previous steps ...
7
8  // Accept incoming connections
9  clientAddrLen = sizeof(clientAddr);
10  newSockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
11
12  if (newSockfd == -1) {
13    std::cout << "Failed to accept connection" << std::endl;
14    return 1;
15  }
16
17  std::cout << "Accepted connection from client" << std::endl;
18
19  return 0;
20}

xxxxxxxxxx
}
 
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
​
int main() {
  int sockfd, newSockfd;
  struct sockaddr_in serverAddr, clientAddr;
  socklen_t clientAddrLen;
​
  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
​
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);
​
  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
​
  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

Try this exercise. Fill in the missing part by typing it in.

To accept an incoming connection on a socket, you need to call the _____________() function. This function blocks until a connection is made and returns a valid socket descriptor if a connection is successfully established.

Write the missing line below.

To send data over a socket in C++, you need to perform the following steps:

Create a socket using the socket() function. Specify the address family (usually AF_INET for IPv4), the socket type (usually SOCK_STREAM for TCP), and the protocol (usually 0 to let the system choose).
TEXT/X-C++SRC
```
1#include <sys/socket.h>
2int sockfd = socket(AF_INET, SOCK_STREAM, 0);
```
Set up the server address by creating a sockaddr_in structure and filling in the necessary details. This includes the address family (AF_INET), port number (converted to network byte order using htons()), and IP address (converted to binary form using inet_addr()).
TEXT/X-C++SRC
```
1#include <netinet/in.h>
2struct sockaddr_in serverAddr;
3serverAddr.sin_family = AF_INET;
4serverAddr.sin_port = htons(8080); // change port number if needed
5serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed
```
Connect to the server using the connect() function. Pass the socket descriptor, server address structure, and the size of the server address structure as parameters.
TEXT/X-C++SRC
```
1int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
```
Send data over the socket using the send() function. Pass the socket descriptor, the data to send (converted to a C-style string using c_str()), the length of the data, and any additional flags (usually 0).
TEXT/X-C++SRC
```
1std::string data = "Hello, server!";
2status = send(sockfd, data.c_str(), data.size(), 0);
```

Check the return value of send() to ensure the data was sent successfully.

TEXT/X-C++SRC

1if (status == -1) {
2  std::cout << "Failed to send data" << std::endl;
3  return 1;
4}

Close the socket using the close() function.
TEXT/X-C++SRC
```
1close(sockfd);
```

Here's an example code that demonstrates how to send data over a socket in C++:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4
5int main() {
6  // Create a socket
7  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
8  if (sockfd == -1) {
9    std::cout << "Failed to create socket" << std::endl;
10    return 1;
11  }
12
13  // Set up the server address
14  struct sockaddr_in serverAddr;
15  serverAddr.sin_family = AF_INET;
16  serverAddr.sin_port = htons(8080); // change port number if needed
17  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed
18
19  // Connect to the server
20  int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
21  if (status == -1) {
22    std::cout << "Failed to connect to server" << std::endl;
23    return 1;
24  }
25
26  // Send data
27  std::string data = "Hello, server!";
28  status = send(sockfd, data.c_str(), data.size(), 0);
29  if (status == -1) {
30    std::cout << "Failed to send data" << std::endl;
31    return 1;
32  }
33
34  std::cout << "Data sent successfully" << std::endl;
35
36  // Close the socket
37  close(sockfd);
38
39  return 0;
40}

xxxxxxxxxx
}
 
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
​
int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  // Set up the server address
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080); // change port number if needed
  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed
​
  // Connect to the server
  int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
  if (status == -1) {
    std::cout << "Failed to connect to server" << std::endl;
    return 1;
  }
​
  // Send data
  std::string data = "Hello, server!";
  status = send(sockfd, data.c_str(), data.size(), 0);
  if (status == -1) {

Try this exercise. Is this statement true or false?

True or false swipe question for Sending Data

Press true if you believe the statement is correct, or false otherwise.

To receive data over a socket in C++, you need to perform the following steps:

Create a buffer to store the received data. The buffer can be a character array or a string.
TEXT/X-C++SRC
```
1#include <iostream>
2const int bufferSize = 1024;
3char buffer[bufferSize];
```
Use the recv() function to receive data. Pass the socket descriptor, the buffer, the size of the buffer, any additional flags (usually 0), and any necessary error handling.
TEXT/X-C++SRC
```
1int bytesReceived = recv(sockfd, buffer, bufferSize, 0);
2if (bytesReceived == -1) {
3  std::cout << "Error receiving data" << std::endl;
4  return 1;
5}
```
Check the value of bytesReceived to determine if data was successfully received. If bytesReceived is 0, it means the connection has been closed by the other side.
TEXT/X-C++SRC
```
1if (bytesReceived == 0) {
2  std::cout << "Connection closed" << std::endl;
3}
```
Process the received data stored in the buffer as needed.
TEXT/X-C++SRC
```
1std::cout << "Received data: " << buffer << std::endl;
```

Repeat the receive process as necessary to receive additional data.

TEXT/X-C++SRC

1bytesReceived = recv(sockfd, buffer, bufferSize, 0);
2// Process additional received data

Here's an example code that demonstrates how to receive data over a socket in C++:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3
4int main() {
5  // Create a socket
6  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
7  if (sockfd == -1) {
8    std::cout << "Failed to create socket" << std::endl;
9    return 1;
10  }
11
12  // ... Set up server address and connect to server ...
13
14  // Receive data
15  const int bufferSize = 1024;
16  char buffer[bufferSize];
17  int bytesReceived = recv(sockfd, buffer, bufferSize, 0);
18  if (bytesReceived == -1) {
19    std::cout << "Error receiving data" << std::endl;
20    return 1;
21  }
22
23  if (bytesReceived == 0) {
24    std::cout << "Connection closed" << std::endl;
25  }
26
27  std::cout << "Received data: " << buffer << std::endl;
28
29  // Close the socket
30  close(sockfd);
31
32  return 0;
33}

Are you sure you're getting this? Is this statement true or false?

<INSERT_CONTENT_HERE>

Press true if you believe the statement is correct, or false otherwise.

To properly close a socket in C++, you need to follow these steps:

Use the close() function to close the socket. Pass the socket descriptor as the argument.
TEXT/X-C++SRC
```
1close(sockfd);
```

Handle any necessary error checking after closing the socket.

TEXT/X-C++SRC

1if (close(sockfd) == -1) {
2  std::cout << "Error closing socket" << std::endl;
3  return 1;
4}

Closing a socket is important to free up system resources and maintain proper network communication. Failure to close a socket can lead to resource leaks and potentially impact the network performance.

Here's an example code that demonstrates how to properly close a socket in C++:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3
4int main() {
5  // Create a socket
6  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
7  if (sockfd == -1) {
8    std::cout << "Failed to create socket" << std::endl;
9    return 1;
10  }
11
12  // ... Set up server address and connect to server ...
13
14  // Close the socket
15  if (close(sockfd) == -1) {
16    std::cout << "Error closing socket" << std::endl;
17    return 1;
18  }
19
20  return 0;
21}

xxxxxxxxxx
 
#include <iostream>
#include <sys/socket.h>
​
int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  // ... Set up server address and connect to server ...
​
  // Close the socket
  close(sockfd);
​
  return 0;
}

Try this exercise. Click the correct answer from the options.

What is the proper function to close a socket in C++?

Click the option that best answers the question.

To build a TCP server in C++, you can follow these steps:

Create a socket using the socket() function. Specify the address family, socket type, and protocol.

TEXT/X-C++SRC

1int sockfd = socket(AF_INET, SOCK_STREAM, 0);
2if (sockfd == -1) {
3  std::cout << "Failed to create socket" << std::endl;
4  return 1;
5}

Bind the socket to an address and port using the bind() function. Specify the server address and port in a sockaddr_in structure.

TEXT/X-C++SRC

1struct sockaddr_in serverAddr;
2serverAddr.sin_family = AF_INET;
3serverAddr.sin_port = htons(8080);
4serverAddr.sin_addr.s_addr = INADDR_ANY;
5
6if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
7  std::cout << "Failed to bind socket" << std::endl;
8  return 1;
9}

Listen for incoming connections using the listen() function. Specify the maximum number of queued connections.

TEXT/X-C++SRC

1if (listen(sockfd, 5) == -1) {
2  std::cout << "Failed to listen for connections" << std::endl;
3  return 1;
4}

Accept incoming connections using the accept() function. Specify a sockaddr_in structure to store the client address.

TEXT/X-C++SRC

1struct sockaddr_in clientAddr;
2unsigned int clientAddrSize = sizeof(clientAddr);
3int clientSock = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrSize);
4if (clientSock == -1) {
5  std::cout << "Failed to accept connection" << std::endl;
6  return 1;
7}

Send and receive data on the client socket using the read() and write() functions.

TEXT/X-C++SRC

1char buffer[1024] = {0};
2read(clientSock, buffer, 1024);
3std::cout << "Received message: " << buffer << std::endl;
4
5const char* response = "Hello from the server!";
6write(clientSock, response, strlen(response));

Close the client socket and server socket using the close() function.
TEXT/X-C++SRC
```
1close(clientSock);
2close(sockfd);
```

Here's an example code that demonstrates how to build a TCP server in C++:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4#include <unistd.h>
5
6int main() {
7  // Create a socket
8  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
9  if (sockfd == -1) {
10    std::cout << "Failed to create socket" << std::endl;
11    return 1;
12  }
13
14  // Bind the socket to an address and port
15  struct sockaddr_in serverAddr;
16  serverAddr.sin_family = AF_INET;
17  serverAddr.sin_port = htons(8080);
18  serverAddr.sin_addr.s_addr = INADDR_ANY;
19
20  if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
21    std::cout << "Failed to bind socket" << std::endl;
22    return 1;
23  }
24
25  // Listen for incoming connections
26  if (listen(sockfd, 5) == -1) {
27    std::cout << "Failed to listen for connections" << std::endl;
28    return 1;
29  }
30
31  // Accept incoming connections
32  struct sockaddr_in clientAddr;
33  unsigned int clientAddrSize = sizeof(clientAddr);
34  int clientSock = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrSize);
35  if (clientSock == -1) {
36    std::cout << "Failed to accept connection" << std::endl;
37    return 1;
38  }
39
40  // Send and receive data on the client socket
41  char buffer[1024] = {0};
42  read(clientSock, buffer, 1024);
43  std::cout << "Received message: " << buffer << std::endl;
44
45  const char* response = "Hello from the server!";
46  write(clientSock, response, strlen(response));
47
48  // Close the client socket
49  close(clientSock);
50
51  // Close the server socket
52  close(sockfd);
53
54  return 0;
55}

xxxxxxxxxx
}
 
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
​
double calculate_interest(double principal, double rate, int years) {
  return principal * rate * years;
}
​
int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }
​
  // Bind the socket to an address and port
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080);
  serverAddr.sin_addr.s_addr = INADDR_ANY;
​
  if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }
​
  // Listen for incoming connections

Are you sure you're getting this? Click the correct answer from the options.

What is the purpose of the bind() function in building a TCP server?

Click the option that best answers the question.

To build a TCP client in C++, you can follow these steps:

Create a socket using the socket() function. Specify the address family, socket type, and protocol.

TEXT/X-C++SRC

1int sockfd = socket(AF_INET, SOCK_STREAM, 0);
2if (sockfd == -1) {
3  std::cout << "Failed to create socket" << std::endl;
4  return 1;
5}

Connect to the server using the connect() function. Specify the server address and port in a sockaddr_in structure.

TEXT/X-C++SRC

1struct sockaddr_in serverAddr;
2serverAddr.sin_family = AF_INET;
3serverAddr.sin_port = htons(8080);
4serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5
6if (connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
7  std::cout << "Failed to connect to server" << std::endl;
8  return 1;
9}

Send and receive data on the client socket using the write() and read() functions.

TEXT/X-C++SRC

1const char* message = "Hello from the client!";
2write(sockfd, message, strlen(message));
3
4char buffer[1024] = {0};
5read(sockfd, buffer, 1024);
6std::cout << "Received message: " << buffer << std::endl;

Close the socket using the close() function.
TEXT/X-C++SRC
```
1close(sockfd);
```

Here's an example code that demonstrates how to build a TCP client in C++:

TEXT/X-C++SRC

1#include <iostream>
2#include <sys/socket.h>
3#include <netinet/in.h>
4#include <unistd.h>
5#include <cstring>
6
7int main() {
8  // Create a socket
9  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
10  if (sockfd == -1) {
11    std::cout << "Failed to create socket" << std::endl;
12    return 1;
13  }
14
15  // Connect to the server
16  struct sockaddr_in serverAddr;
17  serverAddr.sin_family = AF_INET;
18  serverAddr.sin_port = htons(8080);
19  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
20
21  if (connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
22    std::cout << "Failed to connect to server" << std::endl;
23    return 1;
24  }
25
26  // Send and receive data
27  const char* message = "Hello from the client!";
28  write(sockfd, message, strlen(message));
29
30  char buffer[1024] = {0};
31  read(sockfd, buffer, 1024);
32  std::cout << "Received message: " << buffer << std::endl;
33
34  // Close the socket
35  close(sockfd);
36
37  return 0;
38}

Try this exercise. Is this statement true or false?

Building a TCP Client involves creating a socket, binding it to an address and port, and accepting incoming connections.

Press true if you believe the statement is correct, or false otherwise.

Generating complete for this lesson!

Introduction to Networking in C++

Topics Covered in this Lesson

Build your intuition. Fill in the missing part by typing it in.

Let's test your knowledge. Fill in the missing part by typing it in.

Are you sure you're getting this? Click the correct answer from the options.

Click the option that best answers the question.

Build your intuition. Is this statement true or false?

Try this exercise. Fill in the missing part by typing it in.

Try this exercise. Is this statement true or false?

Are you sure you're getting this? Is this statement true or false?

Try this exercise. Click the correct answer from the options.

Click the option that best answers the question.

Are you sure you're getting this? Click the correct answer from the options.

Click the option that best answers the question.

Try this exercise. Is this statement true or false?

Programming Categories

Popular Lessons