東方算程譚

#include <iostream>
#include <random>
#include <set>
#include <map>
#include <string>

using namespace std;

int main() {
  const int N = 10; // カード数
  const int trials = 1000; // 試行回数

  mt19937 engine; // メルセンヌ・ツイスター
  uniform_int_distribution<int> dist(0,N-1); // 0..N-1 一様分布
  auto gacha = [&]() { return dist(engine); }; // 0..N-1 一様乱数
  set<int> items; // 入手したカード種
  map<int,int> hist; // 度数分布表

  int max_trials = 0;
  for ( int i = 0; i < trials; ++i ) {
    int draws = 0;
    items.clear();
    // コンプするまでガチャを繰り返し、
    // ガチャ数を度数分布表に累積する
    while ( items.size() != N ) {
      ++draws;
      items.insert(gacha());
    }
    ++hist[draws];
    if ( max_trials < draws ) max_trials = draws;
  }
  // 度数分布を出力する
  for ( int i = N; i <= max_trials; ++i ) {
    cout << i << ':' << string(hist[i],'#') << endl;    
  }  
}

<Window x:Class="DataBindingSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="データ バインディング サンプル" Width="193" SizeToContent="Height" Height="157">
    <StackPanel>
        <TextBox Text="{Binding Count}" FontSize="36" FontWeight="Bold" TextAlignment="Center" />
        <Button Content="+" Command="{Binding IncCommand}" />
        <Button Content="-" Command="{Binding DecCommand}" />
    </StackPanel>
</Window>

#ifndef MAINWINDOWVIEWMODEL_H__
#define MAINWINDOWVIEWMODEL_H__

namespace DataBindingSample {

  public ref class MainWindowViewModel : public System::ComponentModel::INotifyPropertyChanged {
  public:
    property int Count {
      int get();
      void set(int value);
    }

    virtual event System::ComponentModel::PropertyChangedEventHandler^ PropertyChanged;

    void attachCommand(System::Action<Object^>^ inc, System::Action<Object^>^ dec);
    void Update(int count);

    property System::Windows::Input::ICommand^ IncCommand 
      { System::Windows::Input::ICommand^ get(); }
    property System::Windows::Input::ICommand^ DecCommand 
      { System::Windows::Input::ICommand^ get(); }

  private:
    int _Count;
    System::Windows::Input::ICommand^ incCommand;
    System::Windows::Input::ICommand^ decCommand;
  };
 
}

#endif

#ifndef COUNTER_H__
#define COUNTER_H__

namespace DataBindingSample {

  public ref class Counter {
  public:
    void inc();
    void dec();
    int count();

  private:
    int count_;
  };

  public ref class CounterModel : Counter {
  public:

    // Model→ViewModel
    event System::Action<int>^ CountUpdatedHandler;

    // ViewModel→Model 
    property System::Action<Object^>^ Increment { System::Action<Object^>^ get(); }
    property System::Action<Object^>^ Decrement { System::Action<Object^>^ get(); }

  private:

    void Notify();

    void inc(Object^ dummy);
    void dec(Object^ dummy);

  };

}

#endif

/* 
 * App.xaml.cs
 */
using System.Windows;

namespace DataBindingSample {

  public partial class App : Application {

    public static MainWindowViewModel ViewModel {
      get { 
        if ( viewmodel_ == null )
          viewmodel_ = new MainWindowViewModel();
        return viewmodel_;
      }
    }

    public static CounterModel Model {
      get {
        if ( model_ == null )
          model_ = new CounterModel();
        return model_;
      }
    }

    public static MainWindowViewModel viewmodel_;
    public static CounterModel model_;
  }

}

/*
 * MainWindow.xaml.cs
 */
using System.Windows;

namespace DataBindingSample {

  public partial class MainWindow : Window {
    public MainWindow() {
      InitializeComponent();
      this.DataContext = App.ViewModel;
      App.ViewModel.attachCommand(App.Model.Increment, App.Model.Decrement);
      App.Model.CountUpdatedHandler += App.ViewModel.Update;
    }
  }

}

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets
  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

    <CodeSnippet Format ="1.0.0">
        <Header>
            <Title>C++ class decl.</Title>
            <Author>επιστημη</Author>
            <Description>C++ クラス宣言</Description>
            <Shortcut>classdecl</Shortcut>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>CLASS</ID>
                    <ToolTip>クラス名</ToolTip>
                    <Default>CLASS</Default>
                </Literal>
            </Declarations>
            <Code Language ="CPP">
                <![CDATA[class $CLASS$ {
public:
  $CLASS$(); // default ctor
  $CLASS$(const $CLASS$& other); // copy ctor
  virtual ~$CLASS$(); // dtor
  $CLASS$& operator=(const $CLASS$& other); // copy op.
private:
};
]]>
            </Code>
        </Snippet>
    </CodeSnippet>

    <CodeSnippet Format ="1.0.0">
            <Header>
                <Title>C++ class impl.</Title>
                <Author>επιστημη</Author>
                <Description>C++ クラス実装</Description>
                <Shortcut>classimpl</Shortcut>
            </Header>
            <Snippet>
                <Declarations>
                    <Literal>
                        <ID>CLASS</ID>
                        <ToolTip>クラス名</ToolTip>
                        <Default>CLASS</Default>
                    </Literal>
                </Declarations>
                <Code Language ="CPP">
                    <![CDATA[// default ctor
$CLASS$::$CLASS$() {
}

// copy ctor
$CLASS$::$CLASS$(const $CLASS$& other) {
  if ( this != &other ) {
  }
  return *this;
}

// dtor
$CLASS$::~$CLASS$() {
}

// copy op.
$CLASS$& $CLASS$::operator=(const $CLASS$& other) {
  return *this;
}
]]>
                </Code>
            </Snippet>

        </CodeSnippet>
</CodeSnippets>

#include <iostream>

using namespace System;
using namespace std;

public ref class Counter {
public:
  delegate void OnUpdate(Counter^ counter);
  Counter() : value_(0) {}
  void incr() { ++value_; handler(this); }
  property int count { int get() { return value_; }}
  event OnUpdate^ handler;
private:
  int value_;
};

void print_fun(Counter^ counter) {
  cout << counter->count << endl;
}

int main() {
  Counter^ counter = gcnew Counter();
  auto print_lambda = [](Counter^ counter) { cout << counter->count << endl; };
  counter->handler += gcnew Counter::OnUpdate(print_fun);    // OK
  counter->handler += gcnew Counter::OnUpdate(print_lambda); // error
  counter->incr();

  return 0;
}

#include <iostream>
#include <locale>
#include <Windows.h>

using namespace std;

int main() {
  wcout.imbue(locale("japanese"));
  // EnumWindows に与える CALLBACK に stateless lambda を。
  EnumWindows([](HWND hWnd, LPARAM lParam)->BOOL {
                TCHAR buf[256];
                GetWindowText(hWnd, buf, 256);
                if ( buf[0] != L'\0' ) {
                  *reinterpret_cast<wostream*>(lParam) << buf << endl;
                }
                return TRUE;
              }, 
              reinterpret_cast<LPARAM>(&wcout));
}

#include <iostream>

using namespace std;

template<typename T>
class iterap {
public:
  iterap(T t) : value_(t) {}
  iterap(const iterap& other) : value_(other.value_) {}
  iterap& operator=(const iterap& other) { value_ = other.value_; }
  T operator*() const { return value_; }
  iterap& operator++() { ++value_; return *this; }
  iterap  operator++(int) { return value_++; }
  friend bool operator==(const iterap& x, const iterap& y) { return x.value_ == y.value_; }
  friend bool operator!=(const iterap& x, const iterap& y) { return !(x == y); }
  friend bool operator< (const iterap& x, const iterap& y) { return x.value_ < y.value_; }
  friend bool operator>=(const iterap& x, const iterap& y) { return !(x < y);  }
  friend bool operator> (const iterap& x, const iterap& y) { return y < x;     }
  friend bool operator<=(const iterap& x, const iterap& y) { return !(y < x);  }
private:
  T value_;
};

template<typename T>
class iterange {
public:
  iterange(T first, T last) : first_(first), last_(last) {}
  iterap<T> begin() const { return iterap<T>(first_); }
  iterap<T> end() const { return iterap<T>(last_); }
private:
  T first_;
  T last_;
};


int main() {
  for ( auto n : iterange<int>(0,6) ) {
    cout << n << ' ';
  }
}

#include "stdafx.h"
#include "CppUnitTest.h"
#include <Counter.h>

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace TestCounter {

  TEST_CLASS(TestCounter) {
  public:
                
    TEST_METHOD(test_initialize) {
      Counter c;
      Assert::AreEqual(0, c.get());
    }

    TEST_METHOD(test_incr) {
      Counter c;
      c.incr();
      Assert::AreEqual(1, c.get());
    }

  };

}