常連

クリップコレクター

注目の的

社会貢献

質問力

拍手喝采

質問者

情報収集家

模範生

自己紹介

有名人

###前提・実現したいこと

テーブルの、行に対してリンクを設定したいです。
最終的に行うつもりなのは以下の2点ですが、今回質問させていただきたいのは 1 についてです。

1. hover 時の背景色変更
2. クリック時に javascript を実行 (show-modal)


###発生している問題

最初、tr に対して :hover を設定してみたのですが、
rowspan をしている箇所があり、一部のセルに hover した場合のみ反応させたくありません。
そもそも可能なのだろうかと思っているのですが、何か方法はあるでしょうか…

以下試したCSS (test01, test02)
rowspan している「ドリンク」セルのhoverで一行目を着色したくないです。
```html
<style>
  table { margin-bottom:2em; border-collapse:collapse; }
  td    { border:1px solid #999; padding:0.2rem; }

  /* test01
     trのhoverで、子tdの背景色を変更
     問題点：「ドリンク」セルのhoverで一行目を着色したくない
  */
  .test01 .rowlink-tr:hover .rowlink-td {
      background:yellow;
  }
  /* test02
     tdのhoverで、自身と兄弟tdの背景色を変更
     問題点：弟要素は着色されるが、兄要素が着色されない
  */
  .test02 .rowlink-td:hover,
  .test02 .rowlink-td:hover ~ .rowlink-td {
      background:yellow;
  }
</style>


<table class="test01">
  <tr class="rowlink-tr">
    <td class="rowlink-td-nohover" rowspan="3">ドリンク</td>
    <td class="rowlink-td">珈琲</td>
    <td class="rowlink-td">210円</td>
    <td class="rowlink-td">おかわり自由</td>
  </tr>
  <tr class="rowlink-tr">
    <td class="rowlink-td">紅茶</td>
    <td class="rowlink-td">240円</td>
    <td class="rowlink-td"></td>
  </tr>
  <tr class="rowlink-tr">
    <td class="rowlink-td">オレンジジュース</td>
    <td class="rowlink-td">230円</td>
    <td class="rowlink-td"></td>
  </tr>
</table>


<table class="test02">
  <tr class="rowlink-tr">
    <td class="rowlink-td-nohover" rowspan="3">ドリンク</td>
    <td class="rowlink-td">珈琲</td>
    <td class="rowlink-td">210円</td>
    <td class="rowlink-td">おかわり自由</td>
  </tr>
  <tr class="rowlink-tr">
    <td class="rowlink-td">紅茶</td>
    <td class="rowlink-td">240円</td>
    <td class="rowlink-td"></td>
  </tr>
  <tr class="rowlink-tr">
    <td class="rowlink-td">オレンジジュース</td>
    <td class="rowlink-td">230円</td>
    <td class="rowlink-td"></td>
  </tr>
</table>
```

###試したこと

jQuery で潰せないかと思って一応試したのですが、無理でした。（まあ無理です･･･よね･･･）
```javascript
$(function() {
    // nohover が指定されているセルでは hover を発生させない（rowspan対応）
    $(".rowlink-td-nohover").on("mouseover mouseenter", function(e) {
        //alert("hoge");
        e.preventDefault();
        return false;
    });
});
```

###補足情報(言語/FW/ツール等のバージョンなど)
ひとまず IE11, Chrome で動くようにしたいです。

###その他

もうそもそもマウスカーソルを載せた時の着色を、css の :hover ではなく jQuery で処理しないと無理かな、とちょっと思ったのですが、可能であれば極力 css で実現したいです。

それはもう css では無理だよ、というご意見でも良いのでよろしくお願いします。

trのhoverを一部のセル上でのみ無効にする

### 前提・実現したいこと
Snapdragon410搭載のボード上でLinaro Debian（Linux kernel 4.14.0ベース）を動かしています。
自作のアプリケーションを動かしているとOSがハングアップしてしまう現象が起きました。（早いと1日、遅いと14日、1カ月以上動かしても発生しないことも。）
ボード上にI2Cデバイスがのっており、そのドライバを自作していましたが、それに問題を見つけました。
/devにデバイスファイルを作成し、それをopenしてread/writeをコールするようなドライバです。（アプリの中からコールしています。）
そのwriteの実装を以下のようにしていました。
```C
static ssize_t mydevice_write(struct file *fp, const char __user *buf, size_t count, loff_t *f_pos)
{
    s32 ret;

    ret = i2c_smbus_write_byte_data(i2c_client, buf[0], buf[1]);
    if(ret < 0) {
        return ret;
    }

    return count;
}
```

ユーザー空間で確保したメモリbufを直接参照していました。
copy_from_userを使うべきであり、以下のように修正しました。
```C
static ssize_t mydevice_write(struct file *fp, const char __user *buf, size_t count, loff_t *f_pos)
{
    s32 ret;
    char wdata[2] = {0};

    if (count > 2) {
        return -EINVAL;
    }

    if (copy_from_user(wdata, buf, count)) {
        return -EFAULT;
    }

    ret = i2c_smbus_write_byte_data(i2c_client, wdata[0], wdata[1]);
    if(ret < 0) {
        return ret;
    }

    return count;
}
```

修正版のドライバで動かしていますが、今のところOSがハングアップしてしまう現象は起こってないです。
しかし、本当にこれが原因だったのか自信が無いという状況です。
調べた限りでは、ユーザー空間で確保したメモリがスワップされ、RAM上に無いときに参照しようとするとエラーが起きるということでした。
しかし、動作環境ではスワップ領域を作成していないため、スワップは起きません。
実際にこの問題が起きる直前までvmstatで監視していましたが、スワップは起きていませんでした。

私が調べた以外の条件でもエラーが起きることは考えられるのでしょうか？

### 発生している問題・エラーメッセージ
/var/log/を確認しましたがOSがハングアップしたときのログは何も記録されていませんでした。

カーネル空間でユーザー空間で確保したメモリを直接参照

当方Haskellを学び始めた初学者です。
競プロ関係の記事を見ているときに、よく
```haskell
putStrLn $ show ...
```
というコードを見かけます。
しかし、少し調べてみると、
```haskell
print = putStrLn $ show 
```
という話を聞きました。
つまり、putStrLn $ showはprintと同じ役割をするのでは？という話です。しかし、printに文字列"Hello"を入力すると、出力は"Hello"とクォーテーション付きになります。

これは、文字列にshowを適用すると、クオーテーションを含めた文字列になるということなのでしょうか？

Haskellにてputstrlnとprintの違い

##聞きたいこと
タイトルの通り、なぜMacやWindows上でわざわざLinuxを使用する人が多いのか知りたいです。

というのも、Youtubeでtutorialなどの動画を見ていると、
元々のOSがWindowsやMacOSでありながらわざわざVirtualBoxなどの仮想化ツールを使用してLinuxを使っている人が多く見られます。

その動画の中で使用しているエディタはOSに依存しないSublime TextやVim、EmacsなどといったわざわざLinuxを使用する必要性がないものばかりです。

また、ブラウザに関してもほとんどがChromeを使用しており、
正直Linuxでなくとも元々のOSで問題がないように感じます。

なぜ彼らはわざわざ仮想化をしてまでLinuxを使用するのでしょうか？

MacやWindows上でわざわざLinuxを使用する理由

いつもお世話になっております。

今回は関数型プログラミングについてなのですが、自分の経験ではほんの一部、関数型プログラミングで記載し、メインの処理は他の言語に投げるような処理しか経験がなく、関数型プログラミングって一時騒がれた割にはあまり使われてないのかな？と疑問に思った次第です。そこで質問です


１．プログラム言語を選定するときに、関数型プログラミングを採用したい（したくない）と判断した材料ってどんなものがありましたか？

２．どのようなシステムで関数型プログラミングは生かされやすいと思いますか？

３．処理をがっつり書く（MVCだったら、モジュールに該当する部分）のには向いていないのでしょうか？


回答のほど、お願いいたします。

なお、抽象的な質問だと思うので 8/1のどこかで回答済にしたいと思っています。


以上

関数型プログラミングって、使いやすいですか？

とりあえず、c++11 をある程度（言語が巨大なのでほんの少し）勉強してから、その上を勉強しようかなと思っているレベルの者です。

### 知りたいこと

c++ のクラスに、論理否定演算子「!」をオーバーロードする場合はどんな場合なのでしょうか？
例えば std::basic_ios では operator!() がオーバーロードされていますが、同時に、キャスト演算子　explicit operator bool() const;もオーバーロードされています。

しかし、operator bool() があれば、たとえexplicitがついていても、否定演算子!のオペランドの場合は明示的なキャストなしにbool型に変換されます。
またbool() と operator!() の両方がクラスAでオーバーロードされている場合、a が A のインスタンスのとき、!a と !static_cast<bool>(a) は同じ動作をするようにしないと使う方が混乱します。
とすると、多くの場合、 explicit operator bool() のみがあれば大丈夫のような気がするのですが、あえて 否定演算子のオーバーロードをする積極的な理由は何なのでしょうか？
たとえば、std::shared_ptr では!のオーバーロードはないようですね。
もし、論理演算子をオーバーロードする必用が在る場合でも「&&」「||」は短絡評価ができなくなるため危険ですから、普通は「!」しかできませんが。

自分でクラスを作るとき、!のオーバーロードを行うか否か？の指針が知りたいです。

### 試したこと
```c++
// test-not2.cpp
#include <iostream>

class A {
public:
  operator int() const {return 0;}　// explicit をつけると当然のようにエラー
};

class B {
public:
  explicit operator bool() const {return false;}
};

class C {
public:
  bool operator!() const { return false;}
};

class D {
public:
  explicit operator bool() const {
    std::cerr << "D::operator bool()" << std::endl;
    return false;
  }
  bool operator!() const {
    std::cerr << "D::operator !()" << std::endl;
    return false;
  }
};


using std::cout;
using std::endl;

int main(){
  A a;
  B b;
  C c;
  D d;
  
  cout << "!a: " << !a << endl;
  cout << "!b: " << !b << endl;
  cout << "!c: " << !c << endl;
  cout << "!d: " << !d << endl;
}

```


出力
```
bash@test-not2$ ./a.out
!a: 1
!b: 1
!c: 0
!d: D::operator !()
0
bash@test-not2$ 

```
g++ (Ubuntu 7.3.0-27ubuntu1~18.04) 7.3.0
では、両方オーバーロードした場合、否定演算子が優先されたようです。

c++ のクラスで否定演算子!を積極的にオーバーロードする場合はどんな時なのでしょうか？

### 実現したいこと

高速で画面上の指定座標上のRGB値を取得する（欲張った目標としては毎秒10000ピクセル程度の速度での解析、最低でも毎秒1500～3000ピクセル）
##問題点

以下のサンプルコードを参考に色々いじって30x16ピクセル分を取得するプログラムを作成したのですが、GetPixelのせいでたったそれだけを解析するのに五秒くらい時間がかかってしまいます。（printfもなにげに処理に時間を使うのでそれを取り除いた場合でも同じくらい時間がかかります）
bmp画像上のRGBを取得するプログラムをメモリに展開し、解析するプログラムでやったことがありますがその時は全く処理に時間を必要としなかったので頑張ればいけるのではないのかなと思っています。


```C++
#include <windows.h>
#include <stdio.h>
#include<string>
#include<iostream>
using namespace std;

int main(void)
{
	int exit;
	
	HWND hWnd;
	HDC hdc;
	COLORREF clr;
	INT x, y;
	x = 1;
	y = 1;

	hWnd = GetDesktopWindow();
	hdc = GetWindowDC(hWnd);
	clr = GetPixel(hdc, x, y);
	ReleaseDC(hWnd, hdc);
	printf("RGB = (%d,%d,%d)\n",
		GetRValue(clr),
		GetGValue(clr),
		GetBValue(clr));

	cin >> exit;//なぜかキーを入力したら終了しますと表示されずに勝手に終了してしまうための対策用
	return 0;
}
```
【参考】[Yahoo知恵袋](https://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q1234959407)

### 試したこと
処理の並列化をしたら少しは早くなるのでは？と思いやろうとしたのですがなぜかOpenMPを有効化にして、とりあえず動作確認でサンプルコードで動かしてみたのですが、”2フェーズの名前参照は、C++/CLI、C++/CX、OpenMP ではサポートされていません。/Zc:twoPhase- を使用します”と警告が出てきてったので諦めました...(このことについても質問したいのですが今回は大丈夫です。)


### 補足情報（FW/ツールのバージョンなど）
VisualStuido2017,Windws10

C++での画面上のRGB値取得の高速化

`int`や`bool`のような読み込みが原子的だと思われる型について、変更がある場所を全て排他制御されている場合でも、`atomic`を使う必要はあるのでしょうか？

サンプルとして、下記のコードを見てください。

```C++
#include <atomic>
#include <chrono>
#include <iostream>
#include <thread>

int main()
{
	std::atomic_int x(0);
	int y(0);
	std::mutex mw;
	std::mutex mr;
	std::thread thws[1000];
	std::thread thrs[1000];
	for (int i = 0; i < 1000; ++i) {
		thws[i] = std::thread([&]() {
			std::this_thread::sleep_for(std::chrono::seconds(1));
			std::lock_guard<std::mutex> lock(mw);
			x++;
			y++;
		});
		thrs[i] = std::thread([&]() {
			std::this_thread::sleep_for(std::chrono::seconds(1));
			int x_t = x; // ① 安全
			int y_t = y; // ② 危険？？？
			std::lock_guard<std::mutex> lock(mr);
			std::cout << x_t << "," << y_t << std::endl;
		});
	}
	for (int i = 0; i < 1000; ++i) {
		thws[i].join();
		thrs[i].join();
	}
	std::cout << x << "," << y << std::endl;
	return 0;
}
```

`x`は原子的`int`ですが`y`は普通の`int`です。しかし、インクリメントの処理について、mutexによりどちらも排他制御されているため、期待通りに最終的に1000になります(もし、mutexがなければ、`y`は1000で無いときがあります)。

では、読み込み側はどうでしょうか？①は安全でしょう。`x++`の最中に`x`が読み込まれて壊れてしまうことはありません。では②はどうなのでしょうか？`y++`の最中に`y`が読み込まれた場合、おかしな値になることはあるのでしょうか？また、後置インクリメント以外、例えば、前置インクリメントや代入、`+=`などの場合は、うまくいかないとかあるのでしょうか？そして、それらのことは`int`以外の、`bool`や`long long`等の他の整数型についても言えることなのでしょうか？(とりあえず、上のコードを手元で試す限り、`y`がおかしな値を返すことはないようです。)

もし、問題が無ければ、atomicを外して僅かでも処理を速くしたいと考えています(排他制御自体は別の理由で外せないことが前提です)。変更が全て排他制御されていれば、atomicは外しても大丈夫なのかどうかを教えてください。

変更部分が全て排他制御されている場合でもatomicは必要か？

[P0482R5: char8_t: A type for UTF-8 characters and strings (Revision 5)](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0482r5.html)

がC++20に採択され、めでたくchar8_tが標準入りしたわけですが、このP0482R5によくわからない点があります。

Changes since P0482R4の節に

>Updated [depr.locale.category] and [depr.fs.path.factory] with changes suggested by Tim Song to ensure behavior remains unchanged.

とあり、なぜか`codecvt<char16_t, char8_t, mbstate_t>`, `codecvt<char32_t, char8_t, mbstate_t>`, `codecvt_byname<char16_t, char8_t, mbstate_t>`, `codecvt_byname<char32_t, char8_t, mbstate_t>`が追加されています。

codecvtはエラーハンドリングがガバのプーさんだから消すねっ！ということでC++17で多くが、残っていた`codecvt<char16_t, char, mbstate_t>`, `codecvt<char32_t, char, mbstate_t>`, `codecvt_byname<char16_t, char, mbstate_t>`, `codecvt_byname<char32_t, char, mbstate_t>`もC++20でdeprecatedになったことで完全にcodecvtは空気になったと認識していたのですが、
これはUnicode間の変換がガバガバなまま復活を遂げたと理解すればいいのでしょうか・・・？

C++20に採択されたchar8_t型を追加する提案の不可解な点

C/C++初心者ですが、仕事でC++の中規模開発に携わることになりました。今までJavaで開発していたのですが、Javaでの開発は要素数が事前にわかっていれば極力配列を使えと教えられてきましたが、C++では配列を扱うのはstd::vectorがメインのように感じます。処理が簡潔になるのはよくわかるのですが、配列を使ってもっとレガシーな感じで書きたいのですが実際の現場ではどう使われているのか、皆様のご意見をお聞かせ頂きたく投稿させていただきました。

c++では配列[]はあまり使わないものなんですか？

### 背景

C++において関数（関数オブジェクト）を渡して動作をカスタマイズするという設計はよくあると思います。
実際、標準ライブラリ<algorithm>の関数群はそうなっています。
例えば、次のようにソートの第3引数に関数オブジェクトを渡すことはよくあるかと思います。

```cpp
#include <vector>
#include <algorithm>
#include <functional>

int
main() {
  std::vector v{ 1, 2, 3, 5, 9, 4 };
  std::sort(begin(v), end(v), std::greater<int>{});
  // v = [ 9, 5, 4, 3, 2, 1 ]
}
```



### 問題提起

`greater<int>{}`のようにいちいちテンプレートの`<>`を書くのがかっこ悪いです。
なんなら`{}`も邪魔くさいです。
`greater`と書けると嬉しいです。

### 質問

何らかの`foo`という作用があるとします。
`foo`はジェネリックなものとします。
`foo`を関数としても関数オブジェクトとしても使いやすくするためにはどういう設計をすれば良いのでしょうか？
なにか良い方法が無いものでしょうか？
やはりプリプロセッサマクロなのでしょうか？？？

### yohhoyさんの回答を受けて（追記）

次のように関数オブジェクトを定義し、その中でオーバーロードを行う。
その上で、あらかじめinline変数として関数オブジェクトのインスタンスを作っておく。

オーバーロードが自然にできるし、関数としても関数オブジェクトとしても使い勝手がいい。

これは、[**range-v3**](https://github.com/ericniebler/range-v3/)というC++20に提案されているライブラリの実験的実装でも使われている方法であった。
例えば[このソース](https://github.com/ericniebler/range-v3/blob/a2bf5d0596dd2ffc75c2623b62d6226915609622/include/range/v3/view/transform.hpp#L529)にみることができる。
もしかしたらこれが現状（C++17）におけるベストプラクティスなのかもしれないですね。

```cpp
struct foo_t {
  // generic version
  template <class T>
  T operator()(T a) { return a + a; }
  // specialized version
  int operator()(int a) { return a * 10; }
};

inline constexpr auto foo = foo_t{};
```


### 試したこと

#### 関数テンプレート

この方法は関数テンプレートを渡す際にどの実態化なのかを示すためテンプレートパラメータが必須になります。

```cpp
template < class T >
T foo(T a) { return a + a; }

std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo<int> ); // bad
```

#### 関数オブジェクト

transparentな関数オブジェクトを使う方法。
コンストラクトしないと使えないが、テンプレートじゃないだけ多少マシ。

```cpp
struct foo {
  template < class T >
  T operator()(T a) { return a + a; }
};
std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo{} );
```

ただ、普通の関数としてはダメ。

```cpp
foo{}(42); // bad
// ^
```

#### ラムダ式のラッパー

よくある方法として、transparentなラムダ式で関数テンプレートの呼び出しをラップするというものです。
欠点は、記述量が多すぎることです。
これを書くのはとてもとても面倒なことです。
あと、`std::forward<decltype(a)>(a)`がわからないとよく言われるので地味に困ります。

```cpp
// シンプル
std::transform( begin(v), end(v), std::back_inserter(result), [](auto a){ return foo(a); } );

// 完全転送
std::transform( begin(v), end(v), std::back_inserter(result),
                [](auto&& a){ return foo(std::forward<decltype(a)>(a)); } );
```

#### Globalラムダ式

関数オブジェクトのインスタンスを予め作っておくというアイデアですが、クラスを書くのも面倒なのでラムダ式を書きます。
関数テンプレートを書く代わりにラムダ式を書くことにします。

```cpp
inline auto foo = [](auto a){ return a + a; };

std::transform( begin(v), end(v), std::back_inserter(result), foo ); // nice!
```

副次効果として、C++17からラムダ式のoperator()がconstexpr指定されるのでこれいいなぁと思ったのですが、
**ラムダ式にしてしまうとオーバーロードしたくなっても簡単にはできないのです。**

```cpp
inline auto foo = [](auto a){ return a + a; };
inline auto foo = [](int a){ return a + 1; }; // redefinition!
```

C++における関数の受け渡しについて

### 前提・実現したいこと
逆アセンブルについてです。
mov などの命令文の意味これがAT&T記法で書かれているということくらいしか分かりません。
　私が知りたいのはmovの後ろに abs （zbl）とあるのですがこれはいったい何を意味しているのか、cmpときて2とedi（第一引数？）を比較するとのことですが、ediには何も入っていないので比較することは不可能なのではないでしょうか。また、なにも命令がなければ上から下に処理していくという形であっていますでしょうか？
　逆アセンブルという言葉すら知らない状態でこの問題に取り掛かり、知らない言葉などを調べていたのですが、自分の調べる能力、理解力も低くいので今回知識ある人たちに聞くことにしました。つたない文章ですが、ご指導のほどよろしくお願いいたします。
また初学者でも理解できるようなサイト、おすすめの本などありましたら教えていただけると幸いです。
### 発生している問題・エラーメッセージ
Debian（amd64）上で動作するあるプログラムのmain関数の逆アセンブル結果から実行結果0になる特定の文字列を求める問題です。
objdumpの表示です。

### 該当のソースコード

00000000004003c0 <main>:
  4003c0:       48 b8 0f 0e 0d 0b 00    movabs $0xc0601000b0d0e0f,%rax
  4003c7:       01 06 0c
  4003ca:       83 ff 02                cmp    $0x2,%edi
  4003cd:       48 89 44 24 f0          mov    %rax,-0x10(%rsp)
  4003d2:       48 b8 04 05 08 0a 02    movabs $0x70903020a080504,%rax
  4003d9:       03 09 07
  4003dc:       48 89 44 24 f8          mov    %rax,-0x8(%rsp)
  4003e1:       b8 01 00 00 00          mov    $0x1,%eax
  4003e6:       75 59                   jne    400441 <main+0x81>
  4003e8:       48 8b 56 08             mov    0x8(%rsi),%rdx
  4003ec:       31 c0                   xor    %eax,%eax
  4003ee:       89 c1                   mov    %eax,%ecx
  4003f0:       48 ff c0                inc    %rax
  4003f3:       80 7c 02 ff 00          cmpb   $0x0,-0x1(%rdx,%rax,1)
  4003f8:       75 f4                   jne    4003ee <main+0x2e>
  4003fa:       83 f9 08                cmp    $0x8,%ecx
  4003fd:       b8 01 00 00 00          mov    $0x1,%eax
  400402:       75 3d                   jne    400441 <main+0x81>
  400404:       48 8b 32                mov    (%rdx),%rsi
  400407:       31 c0                   xor    %eax,%eax
  400409:       30 c9                   xor    %cl,%cl
  40040b:       48 89 f2                mov    %rsi,%rdx
  40040e:       48 d3 ea                shr    %cl,%rdx
  400411:       83 e2 0f                and    $0xf,%edx
  400414:       0f b6 54 14 f0          movzbl -0x10(%rsp,%rdx,1),%edx
  400419:       48 d3 e2                shl    %cl,%rdx
  40041c:       83 c1 04                add    $0x4,%ecx
  40041f:       48 09 d0                or     %rdx,%rax
  400422:       83 f9 40                cmp    $0x40,%ecx
  400425:       75 e4                   jne    40040b <main+0x4b>
  400427:       48 33 05 92 ff ff ff    xor    -0x6e(%rip),%rax        # 4003c0 <main>
  40042e:       48 ba 85 03 0e 67 b3    movabs $0x600967b3670e0385,%rdx
  400435:       67 09 60
  400438:       48 39 d0                cmp    %rdx,%rax
  40043b:       0f 95 c0                setne  %al
  40043e:       0f b6 c0                movzbl %al,%eax
  400441:       c3                      retq
```
### 試したこと

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。

アセンブラについて指導お願いします。

# 前提

C99 を想定しています。

この質問は具体的な状況があるわけではなく、言語仕様に対する疑問です。

# 質問

メンバの内容が同じ構造体の宣言をふたつしたとき、このふたつの構造体が同じレイアウトを持つことを保証するような文言は仕様にあるでしょうか？

仕様を確認したところ、構造体のメモリレイアウトについて保証されているのは

- メンバは宣言順に並ぶ
- 構造体を指すポインタはその構造体の先頭要素を指すポインタと互換性がある
- メンバは境界調整済である

というような事柄は書いてありますが

- メンバの間や構造体の最後に詰め物をしてもよい

ともあり、その詰め物 (パディング) の仕方には制約が書かれていないように見えます。

境界調整さえ出来ていれば、例えば乱数だとか名前のハッシュ値だとかで詰め物を余計に入れるなどしてもその処理系は規格には合致すると言えるでしょうか？ もちろんそんなことをする合理的理由は無いので、あくまでも極端な例です。

# 例のソースコード

つまり、こんなコードの動作は仕様で保証されるかということです。

```c
#include <stdio.h>

struct foo {
  char a;
  int b;
};

struct bar {
  char c;
  int d;
};

int main(void) {
  foo foo1 = {1, 2};
  bar bar1 = {3, 4};

  foo* foo2 = &bar1;
  bar* bar2 = &foo1;

  printf("%d, %d\n", foo2.b, bar2.d);
  
  return 0;
}
```

メンバが同じなら構造体のメモリレイアウトは同じか？

[質問「関数へのポインタを返す関数」のSaitoAtsushiさんの回答](https://teratail.com/questions/87117#reply-136187)で

> 他の方の回答では `void*` を使うという提案もありますが、**厳密に言えば言語仕様上は関数ポインタは `void*` よりも大きい幅である可能性がある**のでお勧めできません。

と述べています。私は今まで全てのポインタは同じ大きさであると信じており、すべては`void *`へキャストでき、また、`void *`にキャストされたポインタは元の型に(もちろん同じであるある必要がありますが)キャストできると思っていました。でも、関数ポインタの場合はどうやら異なるようです。

そこで、どのような環境において、どのように異なるのか、また、そのときの`intptr_t`との関係はどうなるのか(そもそもないとか、`void *`に合わせてあるとか)について教えてください。

なお、手元の環境(Win10+Visual Studio 2017、Win10+MSYSY2+Mingw-w64 GCC、Bash on Ubuntu on Windows+GCC、Bash on Ubuntu on Windows+Clang)で下記のコードを試したのですが、32bitでは全て4、64bitでは全て8と、異なる幅であることは確認できませんでした。

```C
#include <stdint.h>
#include <stdio.h>

int main(void)
{
	printf("%zu\n", sizeof(void *));
	printf("%zu\n", sizeof(int *));
	printf("%zu\n", sizeof(double *));
	printf("%zu\n", sizeof(void (*)(void)));
	printf("%zu\n", sizeof(int (*)(int)));
	printf("%zu\n", sizeof(intptr_t));
	return 0;
}
```

その他、N1570のp.580に

> J.5.7 Function pointer casts
> 1 A pointer to an object or to void may be cast to a pointer to a function, allowing data to be invoked as a function (6.5.4).
> 2 A pointer to a function may be cast to a pointer to an object or to void, allowing a function to be inspected or modified (for example, by a debugger) (6.5.4).

とありましたが、互換性のための国際標準を示す付録なので言語仕様外なのかも知れません。C++の仕様は確認できていないです。

C/C++では関数ポインタの大きさがvoid *の大きさを越える場合がある？

# 環境

処理系は clang 6.0.1 と gcc 7.3.0 の 32 ビット版で、 MSYS2 上で使っています。

# 問題

`using` を用いて二次元配列型の別名 `matrix` を定義したのですが、念のために要素の数として与えられた数値が正の数かどうかを `std::enable_if` でチェックするようにしたところ、動作が変わってしまいました。

どうしてこのような差が生まれるのでしょう？

# ソースコード

具体的にいうと、以下のコードでマクロで分岐している箇所を切り替えたような場合です。

```cpp
#include <iostream>
#include <type_traits>

#ifndef ENABLE_SIZE_CHECKING
template<class T, std::size_t Y, std::size_t X>
using matrix = T[Y][X];
#else
template<class T, size_t Y, size_t X>
using matrix = typename std::enable_if<(Y>0)&&(X>0), T[Y][X]>::type;
#endif

template<class T, size_t Y, size_t X>
std::ostream& operator<<(std::ostream& os, const matrix<T, Y, X>& mat) {
  for (auto& i: mat) {
    for (auto j: i) os << j << ',';
    os << std::endl;
  }

  return os;
}

int main() {
  matrix<int, 3, 3> mat;

  for (auto& line: mat) for (auto& element: line) element = 10;
  std::cout << "array rank is "
            << std::rank<decltype(mat)>::value
            << std::endl;
  std::cout << mat <<std::endl;

  return 0;
}
```

# 実行結果

## `std::enable_if` での判定をしない場合

```
array rank is 2
10,10,10,
10,10,10,
10,10,10,
```

## `std::enable_if` での判定をする場合
```
array rank is 2
0x65fec0
```

# 補足

上記のコードでトレイトでの判定も入れていることからわかるように変数は確かに二次元配列として定義されていて、暗黙の型変換が入る余地もないはずなのですが、ポインタとして解釈されているような挙動になっているように思われます。

std::enable_if の有無

現在D言語でファイルを扱うプログラムをテストで組んでいます。
以下のようなコードはファイルレースコンディション脆弱性を含みます。
これを防ぐにはD言語が提供するAPI以外（OS依存）でやらないと実現できないのでしょうか。
```D言語
void main()
{
    string path="test.bin";

    // ファイルがなければ新規作成
    if(!exists(path)){
        // このタイミングで新規作成するファイル名が
        // シンボリックリンクにすり替えられると
        // リンク先が空ファイルとなり破壊される。
        scope File fp = File(path,"wb"); // 空ファイル新規作成
        writeln("created.");
    }
    // シンボリックリンクだったら終了する
    if(isSymlink(path)){
        return;
    }
    // ここから
    writeln("no symlink.");
  // このタイミングでシンボリックリンクへの
    // すり替えが行われると
    File fp = File(path,"rb+");
    // ↓のファイル書き換え処理によるリンク先の書き換えが発生
    fp.rawWrite([0,20,30,40]);
}
```
現状、WindowsとLinux用にソースを分けて書くくらいしか考えられておりませんが、D言語の標準ライブラリで可能ならそちらで対応したいと思っています。
標準ライブラリにアトミックにこれら一連の（チェック&作成、チェック&オープン）処理を行う機能はありますでしょうか。

以上、ご回答のほど宜しくお願い致します。

D言語の単体機能で、ファイルレースコンディションを防ぐ方法

### 厳密な別名規則（strict aliasing rules)で、構造体・共用体をもちいてエイリアシングを実現する方法とは


C言語を独学で勉強しているものです。今回初めて質問させていただきます。
ポインタについて調べていると、strict aliasing rulesというものを発見し、オブジェクトのエイリアス（別名）になるための規則があることを初めて知りました。
その規則は、以下のものであることを学びました。（C99）

オブジェクトに格納された値に対するアクセスは，次のうちのいずれか1つの型を持つ左辺値によらなければならない。

0. オブジェクトの有効型と適合する型
0. オブジェクトの有効型と適合する型の修飾版
0. オブジェクトの有効型に対応する符号付き型または符号無し型
0. オブジェクトの有効型の修飾版に対応する符号付き型または符号無し型
メンバの中に上に列挙した型の1つを含む集成体型または共用体型（再帰的に包含されている部分集成体または含まれる共用体のメンバを含む）
0. 文字型


### 発生している問題・エラーメッセージ

このうち、構造体・共用体の規則以外は理解できたのですが、４つ目の

"メンバの中に上に列挙した型の1つを含む集成体型または共用体型（再帰的に包含されている部分集成体または含まれる共用体のメンバを含む)"

がどのような意味を持つのか、そしてどのような形でそのケースのエイリアシングが実現されるのかが分からないです。


### 該当のソースコード
（ポインタのアライメントの未定義については今回は考慮せず、エイリアシングのみを焦点にしています。）

例えばコードが、

```Ｃ言語
#include<stdio.h>
#include<stdlib.h>

typedef struct s {

	double a;
	float b;
	int c;
	short d;


}st_alias;

typedef union t {

	double e;
	float f;
	int g;
	short h;

}uni_alias;


int main(void){
	
	st_alias * ali_s;
	uni_alias * ali_u;

	int test_1 = 10;
	short test_2 = 22;
	double test_3 = 123.4;
	float test_4 = 222.2f;
	


	system("pause");

	return 0;

}

```
のような状態であるとき、"ali_s"と"ali_u"のポインタは、変換におけるアラインメントが正しければ上記の規則によって、main関数内の４つのオブジェクトのエイリアスになることができ、ポインタを経由してアクセス（変更・読み取り）ができるということなのでしょうか？そして、それはメンバアクセス演算子（-> .)によって実現するのでしょうか？

ご教授して下さるととてもありがたいです。どうか宜しくお願いします。

### 試したこと

visual studio 2017 C++ でポインタにオブジェクトのアドレスを代入して、それを経由したアクセスをしたのですが、期待した結果ではありませんでした。（アラインメントによるアドレスの変化はなかったことは確認済みで、それが原因ではないと思っています。）
また、visual studio C++ が strict aliasing rules をサポートしているのかについて調査をしてみたのですが、そのようなものは見つかりませんでした。
もしかしたらそもそもサポートしていないのではないのかと思いました。
（inline関数の外部結合の定義形式も、Ｃ99のものではなくC++の形式をサポートしている状況もあったため、そのようなこともあるのではないのかと…）


### 補足情報（FW/ツールのバージョンなど）
visual studio C++ 2017を利用しています。(.cの形式で使用しています。）
また、strict aliasing rulesの日本語形式のものは、
https://www.jpcert.or.jp/sc-rules/c-exp39-c.htmlから引用させていただきました。

構造体型・共用体のポインタ型を利用したエイリアシングの実現法＜Ｃ言語＞

メンバ変数を実体で持つか、ポインタで持つか、で悩んでおります。

ゲームに登場するオブジェクトの基底クラスを作成しているのですが、
例えば、下記のような場合、Vector3、BoundingCircleは実体で持つべきでしょうか。ポインタで持つべきでしょうか。

実体で持つ利点はオブジェクト生成時に一緒に作成される為nullチェックが必要ないこと、クラス破棄時に一緒に捨てられることだと思っております。
デメリットとしてはヘッダのインクルードが増えてしまうこと、循環参照が起きる可能性があることだと思っております。

ポインタで持つ場合の利点は、生成を遅らせることができる、ヘッダインクルードを減らせる、オブジェクトの差し替えがポインタの入れ替えで済む、だと思っております。
デメリットとしてはnullチェックが必要であることだと思っております。

どちらでも実装することは可能な為、どのように選択すればよいのか迷っております。
ゲームのプラットフォームはPCです。
可能であれば、なぜそう選択するのか理由も合わせて答えて頂けると助かります。

よろしくお願い致します。


class BaseEntity {
 public:
	//------------------------------------------------
	// デフォルトコンストラクタ
	//------------------------------------------------
	BaseEntity( int type, const Vector3& pos )
		: mID( id++ )
	  , mType( type )
		, mPosition( pos )
		, mBoundingCircle( bc ) {}

	//------------------------------------------------
	// 更新
	//------------------------------------------------
	virtual void update(){};

	//------------------------------------------------
	// 描画
	//------------------------------------------------
	virtual void draw(){};

	// getter
	//------------------------------------------------
	// IDを返す
	//------------------------------------------------
	constexpr int getID() const noexcept {
		 return mID;
	}

	//------------------------------------------------
	// Typeを返す
	//------------------------------------------------
	constexpr int getType() const noexcept {
		return mType;
	}

	//------------------------------------------------
	// 位置を返す
	//------------------------------------------------
	constexpr Vector3 getPosition() const noexcept {
		return mPosition;
	}

	//------------------------------------------------
	// コライダを返す
	//------------------------------------------------
	BoundingCircle getCollider() const noexcept {
		return mBoundingCircle;
	}

	// setter
	//------------------------------------------------
	// Typeを設定する
	//------------------------------------------------
	constexpr void setType( int type ) noexcept {
		mType = type;
	}

	//------------------------------------------------
	// Positionを設定する
	//------------------------------------------------
	constexpr void setPositon( const Vector3& pos ) noexcept {
		mPosition = pos;
	}

	//------------------------------------------------
	// コライダを設定する
	//------------------------------------------------
	constexpr void setCollider( const BoundingCircle& bc ) noexcept {
		mBoundingCircle = bc;
	}

private:
	 static int id;                               // オブジェクト生成時に増加させる為、静的
	 int     mID;                                // 一意に識別する為のID
	 int     mType;                   　　　  // オブジェクトのタイプ
	 Vector3 mPosition;               　    // 位置
	 BoundingCircle mBoundingCircle;  // 当たり判定

}

メンバ変数をポインタで持つか実体で持つか

こんにちは。

現在、linuxOSでのc言語のプログラム上でmallocを多数個使って
２次元、３次元配列でメモリを確保しております。
しかし、入力ファイルの要素数が大きくなると、メモリが１００％以上
になるため、配列それぞれがどれほど容量を食っているのか確認したい
と思っています。

そこで、（なるべく）プログラムのソースを変えることなく、
**配列それぞれ
の容量**を**デバッグ**または**プロファイリング**する方法を
お教えいただければと思います。

どうぞよろしくお願いいたします。

//追記（具体的なプログラムと、具体的な知りたい結果　について）
コードは載せられないですが、大体、計算機１台で100GBを使って、
１０台以上を使って並列計算するようなプログラムを、
職場の先輩から引継ぎました。
配列ひとつずつをmalloc_usable_size(hairetu)で確認するのは
面倒そうなので、おすすめの確認方法があればお教えください。

```コードのイメージ
%最初にメモリ確保

int_a[*][*][*]
int_b[*][*][*]
int_c[*][*][*]
int_d[*][*][*]
・・・intの３次元が１０個ぐらい

double_a[*][*]
double_b[*][*]
double_c[*][*]
・・・doubleの２次元が１０個ぐらい

%ループ計算
計算
%ループ終わり　（ループ計算が数時間以上かかる）


```
この計算の実行最中や実行後に、
int_a ・・・　10GB
int_b ・・・　11GB
int_c ・・・　12GB

double_a ・・・　20GB
double_b ・・・　21GB
double_c ・・・　22GB

といったmallocの実際のメモリ量が知りたいと思います。

ｃ言語のmallocで実際に確保されるメモリ量の確認方法

初心者ですがC++を使ってC言語のコンパイラを作りたいと思っています。
最初に字句解析をすると思うのですがどのようにしたらいいのかわからず手も足もでない状況です。
初歩的な質問かもしれませんが、回答よろしくお願いします。