#include <algorithm>
#include <iostream>
#include <random>
#include <string >
int main(void)
{
std::string input = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
std::random_device rnd;
std::string result;
std::sample(input.begin(),
input.end(),
std::back_inserter(result),
8,
rnd);
std::cout << result << std::endl;
return 0;
}

Permalink | 記事への反応(1) | 21:40

2019-05-07

■C++に再挑戦してる

大学時代 C++が嫌いだった。

というより最初のHello Worldでつまずいてそこでやめてしまった。

「なんでstd::coutなんだ？printfじゃダメなのか？どうしてst dio.hを使わないんだ？」

とどっちも使えるという状態がとても気持ち悪くて、結局拡張子をcppとしただけのベターCを使うだけだった。

「リーナス・トーバルズがC++使わないって言ってるらしいぞ。やっぱりできる人はC言語なんだ」などとも考えていたような気がする。

あれから幾年か経った今になって、仕事の都合上C++に触れることになった。

もう長い間CやC++で書かれたより高レイヤーに位置するプログラミング言語ばかり触ってきたので今更感があったが、今もう一度勉強し直す機会を得たと前向きに捉えてやってみることにした。

実際やってみると、なるほどstd::coutはフォーマット指定子に寄らない分便利だなと素直に受け入れられた。

他にもファイルの読み込みにはfopenじゃなくifstreamを使うとか、いろんなものがC++用に書きやすい方法があるのだと知り、それを素直に受け入れられた。

大学時代はその素直さがなかった。年月は俺に素直さを与えた。

Permalink | 記事への反応(1) | 16:56

2019-05-06

■anond:20121001010448

梅毒（第1期・第2期）
感染してから症状が出るまで：3週間～3ヶ月程度　治療期間：2～3ヶ月程度
皮ふや粘膜の小さな傷から、トレポネーマという病原菌が侵入することで発症する性感染症（STD）です。
第1期は性器に痛みをともなわない硬いしこりができ、第2期になると全身（特に手足）に小さな斑点が多数出てきます。
男女とも症状が出ないタイプがあり、この場合は専用の血液検査で判明することが多いようです。

梅毒検査もしようぜ。

Permalink | 記事への反応(0) | 14:21

2019-01-01

■anond:20181231104029

// WindowsProject7.cpp: アプリケーションのエントリ ポイントを定義します。
//

#include "stdafx.h"
#include "WindowsProject7.h"

#define MAX_LOADSTRING 100

// グローバル変数:
HINSTANCE hInst;                                // 現在のインターフェイス
WCHAR szTitle[MAX_LOADSTRING];                  // タイトル バーのテキスト
WCHAR szWindowClass[MAX_LOADSTRING];            // メイン ウィンドウ クラス名

// このコード モジュールに含まれる関数の宣言を転送します:
//ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

#include &lt;list&gt;

class MyWindow;
	
std::list&lt; MyWindow *&gt; windows;

class MyWindow
{
public:

	HWND hWnd;



	MyWindow()
		:hWnd(NULL)
	{
		windows.push_back(this);
	}

	virtual ~MyWindow()
	{
		std::list&lt; MyWindow *&gt;::iterator it;
		for (it = windows.begin(); it != windows.end(); it++)
		{
			if (*it == this)
			{
				windows.erase(it);
				break;
			}
		}
	}

	static MyWindow * find(HWND key)
	{
		std::list&lt; MyWindow *&gt;::iterator it;
		for (it = windows.begin(); it != windows.end(); it++)
		{
			MyWindow *target = *it;

			if (target-&gt;hWnd == key)
			{
				return target;
			}

		}

		return NULL;
	}



	//
	//  関数: MyRegisterClass()
	//
	//  目的: ウィンドウ クラスを登録します。
	//
	ATOM MyRegisterClass(HINSTANCE hInstance)
	{
		WNDCLASSEXW wcex;

		wcex.cbSize = sizeof(WNDCLASSEX);

		wcex.style = CS_HREDRAW | CS_VREDRAW;
		wcex.lpfnWndProc = WndProc;
		wcex.cbClsExtra = 0;
		wcex.cbWndExtra = 0;
		wcex.hInstance = hInstance;
		wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WINDOWSPROJECT7));
		wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
		wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
		wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_WINDOWSPROJECT7);
		wcex.lpszClassName = szWindowClass;
		wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

		return RegisterClassExW(&amp;amp;wcex);
	}

	//
	//   関数: InitInstance(HINSTANCE, int)
	//
	//   目的: インスタンス ハンドルを保存して、メイン ウィンドウを作成します。
	//
	//   コメント:
	//
	//        この関数で、グローバル変数でインスタンス ハンドルを保存し、
	//        メイン プログラム ウィンドウを作成および表示します。
	//
	BOOL InitInstance()
	{
		hInst = hInstance; // グローバル変数にインスタンス処理を格納します。

		ATOM c = MyRegisterClass(hInstance);


		hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
			CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

		if (!hWnd)
		{
			return FALSE;
		}

		return TRUE;
	}

	BOOL ShowWindow()
	{
		BOOL ret;
		ret = ::ShowWindow(hWnd, SW_SHOW);
		::UpdateWindow(hWnd);

		return ret;
	}


	HINSTANCE hInstance;
	MSG msg;

	BOOL Main()
	{

		HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSPROJECT7));

		// メイン メッセージ ループ:
		while (GetMessage(&amp;amp;msg, nullptr, 0, 0))
		{
			if (!TranslateAccelerator(msg.hwnd, hAccelTable, &amp;amp;msg))
			{
				TranslateMessage(&amp;amp;msg);
				DispatchMessage(&amp;amp;msg);
			}
		}


		return TRUE;

	}

	BOOL OnPaint()
	{
		return TRUE;
	}


};


int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: ここにコードを挿入してください。

    // グローバル文字列を初期化しています。
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WINDOWSPROJECT7, szWindowClass, MAX_LOADSTRING);
    //MyRegisterClass(hInstance);



	MyWindow win;



	win.hInstance = hInstance;

	// アプリケーションの初期化を実行します:
	if (!win.InitInstance())
	{
		return FALSE;
	}

	BOOL ret;

	win.ShowWindow();

	ret = win.Main();

	if (ret)
	{
		return 0;
	}else {
		return (int)win.msg.wParam;
	}



}






//
//  関数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    メイン ウィンドウのメッセージを処理します。
//
//  WM_COMMAND  - アプリケーション メニューの処理
//  WM_PAINT    - メイン ウィンドウの描画
//  WM_DESTROY  - 中止メッセージを表示して戻る
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 選択されたメニューの解析:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &amp;amp;ps);

			MyWindow *target = MyWindow::find(hWnd);
			target-&gt;OnPaint();


            // TODO: HDC を使用する描画コードをここに追加してください...
            EndPaint(hWnd, &amp;amp;ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// バージョン情報ボックスのメッセージ ハンドラーです。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

Windowsのシステムは基本　グローバル関数なので

グローバル関数＜＞クラス化されたメソッドの

ブリッジ関数を書いた

Permalink | 記事への反応(1) | 16:18

2018-12-23

■anond:20181223184745

この辺になってくると初心者の人は面倒かな？

解説をつければかなりわかりやすい

基本的な書き方


class mystring
{
public:
	char *buffer;
	mystring() 
	{
		buffer = (char*)"";
	}

	void operator = (const char*t)
	{
		int len = strlen(t);
		buffer = new char[len + 47];
		strcpy(buffer, t);
	}

	void operator = (const mystring&amp;src)
	{
		int len = strlen(src.buffer);
		buffer = new char[len + 47];
		strcpy(buffer, src.buffer);
	}

	mystring&amp; operator + (const char*t)
	{
		int len = strlen(buffer);
		int len2 = strlen(t);
		char *buffer2 = new char[len + len2 + 47];
		strcpy(buffer2, buffer);
		strcpy(buffer2+len, t);
		buffer = buffer2;
		return *this;
	}
	mystring&amp;  operator + (const mystring&amp;src)
	{
		return ((*this) + src.buffer);
	}

};

STL化したもの

class mystringV
{
public:
	std::vector&lt;char&gt; buffer;
	mystringV()
	{
		buffer.resize(2);
		buffer[0] = ' ';
		buffer[1] = NULL;
	}

	void operator = (const char*t)
	{
		int len = strlen(t);
		buffer.resize(len+1);
		strcpy(&amp;buffer.at(0), t);
	}

	void operator = (const mystringV&amp;src)
	{
		buffer = src.buffer;
	}

	mystringV&amp; operator + (const char*t)
	{
		int len = strlen(&amp;buffer.at(0));
		int len2 = strlen(t);

		buffer.resize(len + len2 + 47);

		strcpy(&amp;buffer.at(0) + len, t);

		return *this;
	}
	mystringV&amp;  operator + (const mystringV&amp;src)
	{
		return ((*this) + &amp;src.buffer.at(0));
	}

};

考察

様々な話はあるもののSTLの方を使えば

いろんな事をプログラマにかわってライブラリがやってしまうということ

どうなんだろうね。

この辺は　あまりしっかり　おしえてもらえないところではある。

でも　プロならみんな　知っている

Permalink | 記事への反応(1) | 20:54

■anond:20181223182722

一気に並べてみる

バッファをつかってループを１つ削る

	int i;
	int space;
	char buffer[8];
	char buffer2[8];
	memset(buffer, 0, 8);
	memset(buffer2, 0, 8);
	for (int i = 0; i &lt; 8; i++)
	{
		memset(buffer, 0x20, i);
		printf("%sHello world\n",buffer);

	}

memsetも削ってみる

	int i;
	int space;
	char buffer[8];
	char buffer2[8];
	memset(buffer, 0, 8);
	memset(buffer2, 0, 8);
	for (int i = 0; i &lt; 8; i++)
	{
		buffer[i] = 0x20;
		printf("%sHello world\n",buffer);

	}

この場合は特に影響はないが一般的にはmemsetを使う使わないは大きな影響になるので

memsetを削る場合は注意が必要

C++を使ってみる

	std::string space;
	for (int i = 0; i &lt; 8; i++) {
		printf("%sHello world\n", space.c_str());
		space += " ";
	}

C++を使ってみるの別回答

	std::string space_org;
	for (int i = 0; i &lt; 8; i++) {
		std::string space = space_org + " ";
		printf("%sHello world\n", space.c_str());
		space_org = space;
	}

考察

ざつにかんがえても　書き方いろいろ　

それぞれメリット　 デメリットが有る

つまり　まぁ　どれがいいというよりは

状況に応じてかき分けていく必要がある

学校の授業などだと

アルゴリズムの話で

ヒープソート　マージソート　クイックソートの比較みたいな話があるけど

そこまで難しい話にいかなくても

ハローワールドだけ見てかつ雑に考えてもこのぐらいは

書き方がたくさんある

どれを書くか？どれがいいか？　考えると面白い

Permalink | 記事への反応(2) | 18:32

■anond:20181223182447

	std::string space;
	for (int i = 0; i &lt; 8; i++) {
		printf("%sHello world\n", space.c_str());
		space += " ";
	}

　↑　C++的　な　書き方１

	std::string space_org;
	for (int i = 0; i &lt; 8; i++) {
		std::string space = space_org + " ";
		printf("%sHello world\n", space.c_str());
		space_org = space;
	}

こっちの書き方のほうが　無駄は多いけど　使いやすい

Permalink | 記事への反応(1) | 18:27

■anond:20181223162005

	std::string space;
	for (int i = 0; i &lt; 8; i++) {
		printf("%sHello world\n", space.c_str());
		space += " ";
	}

＆LT;は＜

例外的に

効率は悪いけど　こういうふうな書き方もできるC++

Permalink | 記事への反応(2) | 18:24

2018-12-16

■anond:20181216143447

ハイライトできないがまぁまぁ見れるようになった。

・'<'と'>'と空白を数値文字参照に変換

・以下のように置換

行頭→<tt>

行末→</tt>

改行→<br>

#include <iostream>

template<int N> struct int_ {};
template<bool B> struct bool_ {};

struct continue_{};
struct end_{};

template <bool Cond>
auto is_end(bool_<Cond>)
-> typename std::conditional<Cond, end_, continue_>::type;

template <typename T, int N>
auto add_pointers_impl(T, int_<N>, continue_)
-> decltype(
add_pointers_impl(
std::declval<T*>(),
int_<N - 1>(),
std::declval<
decltype(
is_end(
bool_<N-1 == 0>()
)
)
>()
)
);

template <typename T, int N>
auto add_pointers_impl(T, int_<N>, end_)
-> T;

template <typename T, int N>
auto add_pointers(T, int_<N>)
-> decltype(
add_pointers_impl(
std::declval<T>(),
int_<N>(),
std::declval<
decltype(
is_end(
bool_<N == 0>()
)
)
>()
)
);

int main()
{
typedef decltype(add_pointers(std::declval<int>(), int_<3>())) result;

result pppi;
std::cout << typeid(pppi).name() << std::endl;

int*** pppi2;
std::cout << typeid(pppi2).name() << std::endl;

return 0;
}