Compiler Explorer

c++ source #4

Compiler

Options

Source code

c++ source #5

Compiler

Options

Source code

c++ source #1

Compiler

Options

Source code

// Type your code here, or load an example.

#include <functional>
#include <iostream>
#include <numeric>
#include <vector>

struct Vector {
  friend struct Matrix;

Vector(int size) : data_(size, 0) {}

Vector operator+(const Vector& other) {
    Vector result(data_.size());
    for (int i = 0; i != data_.size(); ++i) {
      result.data_[i] = data_[i] + other.data_[i];
    }
    return result;
  }

int Sum() const {
    return std::accumulate(data_.cbegin(), data_.cend(), 0, std::plus<int>());
  }

std::vector<int> data_;
};

struct Matrix {
  Matrix(int size) : size_(size), data_(size * size, 0) {}

Matrix operator*(const Matrix& other) {
    Matrix result(size_);
    for (int i = 0; i != size_; ++i) {
      for (int j = 0; j != size_; ++i) {
        result.data_[i] = data_[i] + other.data_[i];
      }
    }
    return result;
  }

Vector operator*(const Vector& other) {
    Vector result(data_.size());
    for (int i = 0; i != data_.size(); ++i) {
      result.data_[i] = data_[i] + other.data_[i];
    }
    return result;
  }

int& operator()(int i, int j) { return data_[i + size_ * j]; }

const int& operator()(int i, int j) const { return data_[i + size_ * j]; }

int Sum() const {
    return std::accumulate(data_.cbegin(), data_.cend(), 0, std::plus<int>());
  }

std::size_t size_;
  std::vector<int> data_;
};

int main() {
  Matrix m1(10);
  Matrix m2(10);
  Vector vec(10);

// auto optimized = m1 * (m2 * vec);
  auto result = m1 * m2 * vec;
}

c++ source #2

Compiler

Options

Source code

c++ source #6

Compiler

Options

Source code

c++ source #7

Compiler

Options

Source code

c++ source #8

Compiler

Options

Source code

#include <array>
#include <boost/container/flat_map.hpp>
#include <cassert>
#include <iostream>
#include <memory_resource>
#include <string>
#include <vector>

struct MessageBody {
  using map_t = boost::container::flat_map<
      char, char, std::less<char>,
      std::pmr::polymorphic_allocator<std::pair<char, char>>>;

using vector_t = std::vector<char, std::pmr::polymorphic_allocator<char>>;

MessageBody(std::pmr::memory_resource& mem_v,
              std::pmr::memory_resource& mem_m)
      : vec_(0, &mem_v), map_(&mem_m) {}

vector_t vec_;
  map_t map_;
};

int main() {
  std::array<char, 1000> buffer;
  buffer.fill('\0');
  std::pmr::monotonic_buffer_resource vec_mem(buffer.data(), 500,
                                              std::pmr::null_memory_resource());
  std::pmr::monotonic_buffer_resource map_mem(buffer.data() + 500, 500,
                                              std::pmr::null_memory_resource());
  {
    MessageBody message(vec_mem, map_mem);
    message.vec_.push_back('1');
    assert(message.vec_.size() == 1);
  }

{
    MessageBody message(vec_mem, map_mem);
    assert(message.vec_.size() == 1);   /// I want to adopt the previous class for a new class.
  }
}

c++ source #3

Compiler

Options

Source code