# Integration with Classical Compute

**Classical integration** allows seamless mixing of quantum and classical C++ code. Call quantum kernels from classical functions, process results, and feed back to quantum.

```cpp
#include "cudaq.h"
#include <vector>
#include <algorithm>
#include <cmath>

// Quantum kernel
struct QuantumPart {
  void operator()(std::vector<double> angles) __qpu__ {
    cudaq::qvector q(angles.size());
    for (size_t i = 0; i < angles.size(); i++) {
      ry(angles[i], q[i]);
    }
    for (size_t i = 0; i < angles.size() - 1; i++) {
      cx(q[i], q[i+1]);
    }
    mz(q);
  }
};

// Classical preprocessing
std::vector<double> preprocess(const std::vector<double>& raw_data) {
  std::vector<double> processed;
  for (auto x : raw_data) {
    processed.push_back(std::sin(x));  // Classical transformation
  }
  return processed;
}

// Classical postprocessing
double postprocess(const auto& quantum_result) {
  double cost = 0.0;
  for (const auto& [bitstring, count] : quantum_result) {
    cost += count * std::stoi(bitstring);
  }
  return cost / 1000.0;  // Average
}

int main() {
  // Classical data
  std::vector<double> raw_input = {0.1, 0.2, 0.3, 0.4, 0.5};
  
  // Step 1: Classical preprocessing
  auto processed = preprocess(raw_input);
  printf("Processed data: ");
  for (auto x : processed) printf("%.3f ", x);
  printf("\n");
  
  // Step 2: Quantum processing
  auto quantum_result = cudaq::sample<QuantumPart>(1000, processed);
  
  // Step 3: Classical postprocessing
  double final_cost = postprocess(quantum_result);
  printf("Final cost: %.6f\n", final_cost);
  
  // Step 4: Use result in classical algorithm
  if (final_cost < 0.5) {
    printf("Quantum result accepted\n");
  } else {
    printf("Quantum result rejected\n");
  }
  
  return 0;
}
```

This hybrid approach combines quantum speedup for specific tasks (sampling, optimization) with classical efficiency for preprocessing, optimization control, and decision-making.