# C++

### **Basic Syntax**

* **Comments**

  ```cpp
  // Single line comment
  /* Multi-line comment */
  ```
* **Headers**

  ```cpp
  #include <iostream> // Standard input-output stream
  #include <string>   // String library
  #include <vector>   // Vector library
  #include <fstream>  // File stream
  #include <sstream>  // String stream
  ```
* **Main Function**

  ```cpp
  int main() {
      // code
      return 0;
  }
  ```

### **Data Types**

* **Primitive Types**

  ```cpp
  int, float, double, char, bool
  ```
* **String**

  ```cpp
  std::string str = "Hello, World!";
  ```
* **Vectors**

  ```cpp
  std::vector<int> vec = {1, 2, 3, 4};
  ```

### **Control Structures**

* **If-Else**

  ```cpp
  if (condition) {
      // code
  } else {
      // code
  }
  ```
* **Switch**

  ```cpp
  switch (expression) {
      case value1:
          // code
          break;
      case value2:
          // code
          break;
      default:
          // code
  }
  ```
* **Loops**

  ```cpp
  // For loop
  for (int i = 0; i < 10; ++i) {
      // code
  }

  // While loop
  while (condition) {
      // code
  }

  // Do-while loop
  do {
      // code
  } while (condition);
  ```

### **Functions**

* **Basic Function**

  ```cpp
  void myFunction() {
      // code
  }

  int add(int a, int b) {
      return a + b;
  }
  ```
* **Function Overloading**

  ```cpp
  void print(int i) {
      std::cout << i << std::endl;
  }

  void print(double f) {
      std::cout << f << std::endl;
  }

  void print(std::string str) {
      std::cout << str << std::endl;
  }
  ```

### **Object-Oriented Programming**

* **Class**

  ```cpp
  class MyClass {
  public:
      int myNum;
      std::string myString;

      void myMethod() {
          // code
      }
  };
  ```
* **Constructor and Destructor**

  ```cpp
  class MyClass {
  public:
      MyClass() { // Constructor
          // code
      }

      ~MyClass() { // Destructor
          // code
      }
  };
  ```
* **Inheritance**

  ```cpp
  class Base {
  public:
      void baseMethod() {
          // code
      }
  };

  class Derived : public Base {
  public:
      void derivedMethod() {
          // code
      }
  };
  ```

### **Pointers and Memory Management**

* **Pointers**

  ```cpp
  int var = 10;
  int* ptr = &var; // Pointer to var

  std::cout << *ptr; // Dereference pointer
  ```
* **Dynamic Memory Allocation**

  ```cpp
  int* ptr = new int;
  *ptr = 10;

  delete ptr; // Deallocate memory

  int* arr = new int[10];
  delete[] arr; // Deallocate array
  ```

### **File I/O**

* **Reading from a File**

  ```cpp
  std::ifstream inFile("example.txt");
  std::string line;
  while (std::getline(inFile, line)) {
      std::cout << line << std::endl;
  }
  inFile.close();
  ```
* **Writing to a File**

  ```cpp
  std::ofstream outFile("example.txt");
  outFile << "Hello, World!" << std::endl;
  outFile.close();
  ```

### **String Manipulation**

* **Concatenation**

  ```cpp
  std::string str1 = "Hello, ";
  std::string str2 = "World!";
  std::string str3 = str1 + str2;
  ```
* **Finding Substring**

  ```cpp
  std::string str = "Hello, World!";
  std::size_t found = str.find("World");
  if (found != std::string::npos)
      std::cout << "Found 'World' at: " << found << std::endl;
  ```
* **Substring**

  ```cpp
  std::string str = "Hello, World!";
  std::string sub = str.substr(7, 5); // "World"
  ```

### **Useful Libraries for Security**

* **Crypto++ (Cryptographic library)**

  ```cpp
  #include <cryptopp/sha.h>
  #include <cryptopp/hex.h>

  std::string sha256(const std::string& input) {
      CryptoPP::SHA256 hash;
      std::string digest;

      CryptoPP::StringSource s(input, true,
          new CryptoPP::HashFilter(hash,
              new CryptoPP::HexEncoder(
                  new CryptoPP::StringSink(digest), true)));

      return digest;
  }
  ```
* **Boost Libraries (General-purpose libraries)**

  ```cpp
  #include <boost/algorithm/string.hpp>

  std::string to_upper(const std::string& str) {
      std::string result;
      boost::to_upper_copy(std::back_inserter(result), str);
      return result;
  }
  ```
* **Poco (Network and other utilities)**

  ```cpp
  #include <Poco/Net/HTTPClientSession.h>
  #include <Poco/Net/HTTPRequest.h>
  #include <Poco/Net/HTTPResponse.h>
  #include <Poco/StreamCopier.h>
  #include <iostream>
  #include <string>

  void http_get(const std::string& host, const std::string& path) {
      Poco::Net::HTTPClientSession session(host);
      Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, path);
      session.sendRequest(request);

      Poco::Net::HTTPResponse response;
      std::istream& rs = session.receiveResponse(response);
      std::string responseBody;
      Poco::StreamCopier::copyToString(rs, responseBody);
      std::cout << responseBody << std::endl;
  }
  ```

### **Common Security-Related Tasks**

* **Buffer Overflow Prevention**

  ```cpp
  char buffer[10];
  std::strncpy(buffer, input.c_str(), sizeof(buffer) - 1);
  buffer[sizeof(buffer) - 1] = '\0'; // Null-terminate
  ```
* **Input Validation**

  ```cpp
  bool is_valid_input(const std::string& input) {
      // Implement validation logic (e.g., regex)
      return true; // or false based on validation
  }
  ```
* **Secure File Handling**

  ```cpp
  std::ifstream inFile("example.txt", std::ios::binary);
  if (!inFile) {
      std::cerr << "Error opening file!" << std::endl;
      return;
  }
  ```
* **Hashing and Encryption (Using Crypto++)**

  ```cpp
  #include <cryptopp/sha.h>
  #include <cryptopp/hex.h>
  #include <cryptopp/aes.h>
  #include <cryptopp/filters.h>
  #include <cryptopp/modes.h>

  std::string sha256(const std::string& input) {
      CryptoPP::SHA256 hash;
      std::string digest;

      CryptoPP::StringSource s(input, true,
          new CryptoPP::HashFilter(hash,
              new CryptoPP::HexEncoder(
                  new CryptoPP::StringSink(digest), true)));

      return digest;
  }

  std::string encrypt_aes(const std::string& plaintext, const std::string& key) {
      std::string ciphertext;
      CryptoPP::AES::Encryption aesEncryption((byte*)key.c_str(), CryptoPP::AES::DEFAULT_KEYLENGTH);
      CryptoPP::ECB_Mode_ExternalCipher::Encryption ecbEncryption(aesEncryption);

      CryptoPP::StringSource(plaintext, true,
          new CryptoPP::StreamTransformationFilter(ecbEncryption,
              new CryptoPP::StringSink(ciphertext)));

      return ciphertext;
  }
  ```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hackerspot.net/cheatsheets/coding/c++.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.