# Parameterized Quantum Circuits

**Parameterized circuits** accept classical parameters (angles, coupling strengths) and use them in gate operations. Essential for variational algorithms where you optimize parameters.

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

// Single parameter
struct SingleParam {
  void operator()(double theta) __qpu__ {
    cudaq::qvector q(1);
    ry(theta, q[0]);
    mz(q[0]);
  }
};

// Multiple parameters
struct MultiParam {
  void operator()(std::vector<double> params) __qpu__ {
    int n = params.size();
    cudaq::qvector q(n);
    
    // Rotation layer
    for (int i = 0; i < n; i++) {
      ry(params[i], q[i]);
    }
    
    // Entangling layer
    for (int i = 0; i < n - 1; i++) {
      cx(q[i], q[i+1]);
    }
    
    mz(q);
  }
};

// Parameters with classical operations
struct ClassicalParams {
  void operator()(double alpha, double beta) __qpu__ {
    cudaq::qvector q(2);
    
    double gamma = alpha + beta;  // Classical computation
    
    ry(alpha, q[0]);
    ry(beta, q[1]);
    rz(gamma, q[0]);  // Use computed parameter
    
    cx(q[0], q[1]);
    mz(q);
  }
};

// Variational loop
int main() {
  std::vector<double> params(5);
  
  // Initialize parameters
  for (int i = 0; i < 5; i++) {
    params[i] = 0.1 * i;
  }
  
  // Optimization loop
  for (int iter = 0; iter < 100; iter++) {
    // Evaluate cost with current parameters
    auto result = cudaq::sample<MultiParam>(1000, params);
    
    // Compute cost from measurement results
    double cost = result.probability("1");
    
    // Update parameters (gradient-based or random search)
    // (In practice, use automatic differentiation)
    params[0] += 0.01;  // Simple update
  }
  
  return 0;
}
```

Parameterized circuits enable efficient variational algorithms: change parameters without rebuilding the circuit. CUDA-Q supports automatic differentiation to compute gradients for optimization.