常連

注目の的

社会貢献

質問力

質問者

情報収集家

模範生

自己紹介

有名人

以下のコードのようにmain関数内に巨大な配列を定義すると強制終了します．

```C++
#include <bits/stdc++.h>

#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)

#define MOD 1000000007

using namespace std;
typedef long long ll;

int main(){
    char s[2000][2000];
    int dp[2000][2000], x[2000][2000], y[2000][2000], z[2000][2000];

    int h,w; cin >> h >> w;
    rep(i,h) rep(j,w) cin >> s[i][j];

    dp[0][0] = 1;

    rep(i,h){
        rep(j,w){
            if(i == 0 && j == 0) continue;

            if(s[i][j] == '.'){
                if(j-1 >= 0) x[i][j] = (x[i][j-1] + dp[i][j-1]) % MOD;
                if(i-1 >= 0) y[i][j] = (y[i-1][j] + dp[i-1][j]) % MOD;
                if(i-1 >= 0 && j-1 >= 0) z[i][j] = (z[i-1][j-1] + dp[i-1][j-1]) % MOD;
                dp[i][j] = (x[i][j] + y[i][j]) % MOD;
                dp[i][j] = (dp[i][j] + z[i][j]) % MOD;
            }
        }
    }

    cout << dp[h-1][w-1] << endl;
}
```

しかし，以下のようにmain関数の外側に巨大な配列を定義すると強制終了を回避することが出来ます．

```C++
#include <bits/stdc++.h>

#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)

#define MOD 1000000007

using namespace std;
typedef long long ll;

char s[2000][2000];
int dp[2000][2000], x[2000][2000], y[2000][2000], z[2000][2000];

int main(){
    int h,w; cin >> h >> w;
    rep(i,h) rep(j,w) cin >> s[i][j];

    dp[0][0] = 1;

    rep(i,h){
        rep(j,w){
            if(i == 0 && j == 0) continue;

            if(s[i][j] == '.'){
                if(j-1 >= 0) x[i][j] = (x[i][j-1] + dp[i][j-1]) % MOD;
                if(i-1 >= 0) y[i][j] = (y[i-1][j] + dp[i-1][j]) % MOD;
                if(i-1 >= 0 && j-1 >= 0) z[i][j] = (z[i-1][j-1] + dp[i-1][j-1]) % MOD;
                dp[i][j] = (x[i][j] + y[i][j]) % MOD;
                dp[i][j] = (dp[i][j] + z[i][j]) % MOD;
            }
        }
    }

    cout << dp[h-1][w-1] << endl;
}
```

これはなぜなのでしょうか？

main関数に配列を宣言すると強制終了する理由を知りたいです（C++）

### 質問

競プロで他の方の解答を見ているとたまに`int main()`ではなく`signed main()`と書く人を見かけます。
これがどういう意味か、なぜこのようなことをするのかが分かりません。わかる方ご回答よろしくお願いします。

競プロでたまに見る "signed main()" とは

### 前提・実現したいこと

プログラミング初心者です。Visual Studio Codeにて以下のプログラムを試しに書いてみてgcc test.cで実行したところ以下のエラーが出ました。解決方法がありましたらよろしくおねがいします(+_+)

### 発生している問題・エラーメッセージ

```
c:/mingw/bin/../lib/gcc/mingw32/6.3.0/../../../libmingw32.a(main.o):(.text.startup+0xa0): undefined reference to `WinMain@16'
collect2.exe: error: ld returned 1 exit status
```

### 該当のソースコード

```C
#include <stdio.h>
int main(void)
{
  printf("Hello world");
  return 0;
}
```

### 試したこと

ネットで調べたことを大体やり、保存やmain関数の中を変えたりしましたがダメでした。
### 補足情報（FW/ツールのバージョンなど）

Win10,言語:C
gcc ver6.3.0
インストール済み：
mingw32-base
mingw32-gcc-g++

Cのコンパイルができない

以下のコードにおいてなぜbの値が3にならないのですか？
関数funcの中の y=*zによってcの値にならないのですか？
お願いします。
```c
#include<stdio.h>
void func(int x,int *y,int **z){
  x = *y;
  y = *z;
  **z =x;
}

int main(void){
  int a = 1,b = 2,c = 3;
  int *cp = &c;
  func(a,&b,&cp);
  printf("a = %d b = %d c = %d\n",a,b,c);
  return 0; 
}
```

ポインタの挙動が分からない

先程、パソコン内のセキュリティチェックを行った所、「ルーターの『HG8045Q』にてポート『7547』が常時開放されていてハッカーから簡単にデータにアクセスされる可能性がある」という風に表示されました。
このポート『7547』をネットで調べてみた所、近年攻撃対象の1つとして挙げられるみたいです。

HG8045Qで常時開放されている理由としては『遠隔管理用のポート』みたいで恐らくプロパイダサポートの遠隔操作なのかな？って思います。
一応、私は自宅サーバーをやっている者なので気になっています。

ここで質問なのですが
・このポートを閉じた方がいいのか（開放されている時の影響力など）
・ポートを閉じたことでのデメリット
・『7547』ポートの閉じ方

以上の3点の回答をよろしくお願いします！

ルーター、ネットワーク関連に詳しい人お願いします！

#知りたいこと
（１）SSLのサイトしか使わないなら公共のフリーWifiでパスワードや重要な通信を行ってもOK？
（２）非SSLサイトでも公共Wifiなど攻撃者と同じネットワークの中にいないなら大丈夫？
（３）公共のフリーWifiを使っていても、パスワード等の重要な通信を行わなければ問題ない？（非SSL通信で）
（４）非SSLと公共フリーWifiの具体的なリスクを知りたい


####（１）SSLのサイトしか使わないなら公共のフリーWifiでパスワードや重要な通信を行ってもOK？
フリーWifiの問題点は下記だと認識しています。

攻撃者と同じネットワークに入ってしまう可能性があり、
パケットキャプチャ等を使われるとSSL通信以外の通信が平文で見られてしまい
パスワード等の重要情報が見られてしまうこと


上記で正しいなら、
SSLサイトしか使わないなら
公共のフリーWifiは重要なサイトでログイン等を行ってもOKということでしょうか？

もし、ブラウザが保持しているクッキーやローカルストレージの値まで見られてしまうということであれば
SSLなどは関係無しに危ないと思うのですが、
通信中のパケットだけが攻撃対象なら大丈夫なの？と疑問に思っています。


###（２）非SSLサイトでも公共Wifiなど攻撃者と同じネットワークの中にいないなら大丈夫？
（１）の認識から、
SSLじゃなくても公共Wifiなどを使わないなら傍受のリスクはない？と疑問に思っています。


###（３）公共のフリーWifiを使っていても、パスワード等の重要な通信を行わなければ問題ない？（非SSL通信で）
（１）の認識から、
そのように思っています。


###（４）非SSLと公共フリーWifiの具体的なリスクを知りたい
セキュリティに関して、
具体的にどういった理由でどのようなリスクがあるのかを知りたいです。

例えば、
公共のWifiは通信が傍受される可能性があるから危険
といった抽象的な話ではなく、

下記のように
どのような手法でどのような被害が起こるのかを教えていただきたいです。

（例）
パケットキャプチャは同じネットワーク内のパケットを見ることができ、
非SSL通信でのパケットにはパスワード等が平文で記載されている。
そのため、公共Wifiで非SSLを行っているサイトに（パスワードを入力して）ログインを行うと、
パケットキャプチャによってパスワードがバレてしまい、
傍受したパスワードを利用してサイトになりすましログインされてしまうリスクがある。



不足している情報等があれば
補足させていただきますので
以上、よろしくお願いします。


追記 2018.11.28
ockeghem様のご回答で
かなり理解が進んだのですが、
その中でまだ理解が怪しい箇所があるため、

ockeghem様とのコメントのやりとりに関して
ご回答をお待ちしております！

SSL通信と公共フリーWifiにおいて、具体的なリスクを知りたい。

カーネル内の実装について、普段プログラマはセマフォやロックを用いて排他制御を行うと思うのですが、これらのセマフォやロックの実装について勉強致しました。
その結果、スピンロックという手法が取られていることがわかりました。ビジーウエイトによる実装ということがわかりました。そこで二つほど疑問ができました。

[こちら](http://www.nces.is.nagoya-u.ac.jp/NEXCESS/blog/index.php?catid=43)のサイトを見る限りだと、そもそもカーネルの割り込みをさせないことが前提になっています。
つまりこれらの処理は単一プロセサに対しては割り込みさせないという処理が大前提になっているのでしょうか？

またスピンロックはあくまでロックの獲得の１手法であり、スピンロックのみ使えばロックが安全に取れる(マルチプロセサ環境で)ということはありませんよね？

よろしくお願いいたします。

セマフォ、ロックの実装について

[質問]
**電気信号は「0」「1」の２つしか認識できないのに、どうしてCPUの命令セットや機械語、アセンブラ、C言語、HTMLなどの文字を認識させることができてのですか？どうしたらそんなことができるようになるのですか？**


[私のベストアンサー]
CPUは「認識」なんかしていませんよ。
より原始的な自動機械であるオルゴール、あれは、音楽を認識しているわけでもなく、さらには「音」を認識しているわけでもなく、単に特定の位置に突起のある原盤(っていうのかな?)に板が引っかかって弾かれて音が出る、それだけの機械です。結果として音楽を奏でているわけですが、しかしそれは「演奏」とは言い難いのでは。
CPUも一緒。ある電気的なレベルの組み合わせが与えられたら決まった動作をすることになっている機械でしかないのです。決まった入力を与えると決まった結果が得られるとしても、機械は認識も理解もしていません。

*****

CPUは、なぜ命令を認識できるのか？

C言語のポインタを返す関数の挙動でいま一つピンとこない点があったので
お聞きします。

例えば，以下のようなコードがあった場合


```C


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

int *a_function(int a, int b) {
    int* c = (int * )malloc(sizeof(int));
    *c = a + b;
    return c;
}

int *b_function(int a, int b) {
    int c;
    c = a + b;
    return &c;
}


int main (int c, char* param[]) {

    int aa = 1;
    int bb = 2;

    int *cc = NULL;
    cc = a_function(aa, bb);
    printf("%p", cc);
    printf("%d", *cc);
}


```

a_functionおよびb_functionがありますが，a_functionは正しく関数内でmallocされたメモリへのアドレスを返却してくれます。

しかしb_functionは関数内で静的に宣言されているint型変数の参照は返却してくれませんでした。(返却以前にコンパイルエラーですが)
このとき
オライリー詳説Cポインタ
https://www.oreilly.co.jp/books/9784873116563/
には関数内のスタックフレームは関数終了時にスタックからポップされるため関数内で宣言したアドレスが有効なものではなくなってしまうと記述がありました。

つまるところ，
(1)a_functionが正しく目的のアドレスへとアクセスできるのはmallocで確保したint型のポインタが参照するメモリ分は関数を抜けても確保されたまま
（呼び出し元でfreeする責任があるが）int型のポインタを返却しても呼び出し元でそこにアクセスできる....と認識しています。
しかし

(2)b_functionでは関数内で宣言したint型(4byte)分のメモリは確保しても関数終了とともに開放される．．．．と認識していますが
関数内で宣言した上記の変数 int c の参照自体は存在して返却できるのではないでしょうか？

上記コードa_functionでコンパイルが通り b_functionがコンパイルエラーになる点がイマイチピンと来ません。
単純に関数内で確保したアドレスを返したければmallocで動的にヒープへとメモリ確保したものを返却すればよさそうなのですが
ちょっと喉に骨がひっかかったような感覚のため質問させてもらいました。

よろしくご教授お願いします。

C言語でポインタ型を返却する関数でmallocした参照を返す場合，局所変数を返す場合の挙動の違い

主にアトミック処理に関する質問です。
いくつか不明な点があります。

アトミック処理とミューテックスの違いについて確認しておきます。
[mutex と atomic の違いは何か、どちらが良いか](https://castaneai.hatenablog.com/entry/2017/10/19/175010)
[アトミック操作](https://www.xlsoft.com/jp/products/intel/perflib/tbb/43/tbb_ugref/tbb_userguide/Atomic_Operations.htm)
> アトミック操作の長所は、ロックに比べて比較的処理が速く、デッドロックやコンボイなどを回避できる点にあります。 短所は、限られた操作しか行うことができず、より複雑な操作を効率良く総合的に扱うには不十分なことです。

次に、ロックフリーについて・・・
C++ストラウストラップ氏の本の中では以下のようにあります。
> ロックフリープログラミングは明示的なロックを使わずに並行プログラムを開発するためのの一連の技法だ。
明示的なロックの代わりに使うのが、小規模オブジェクトに対するデータ競合を防ぐための（ハードウェアが直接サポートする）基礎的な演算である。データ競合が発生しない基礎的な演算は、一般的にアトミック処理と呼ばれる。
・・・
ロックフリー技法を用いると、ロック技法を用いた場合よりも大幅に速度が向上することもある。
標準アトミック型と処理は、従来方式のロックフリーなコードに代わる、可搬性を持った代替手法を提供する。

**[疑問1]**
アトミック処理とは、ミューテックスと同じように排他的処理を提供するが、ミューテックスとは対照的にロックを使用しない。
つまり、**アトミック処理 = ロックフリー**　完全に同値なものだと解釈してよろしいのでしょうか？
アトミックとミューテックスを併用したプログラミングスタイルというものも存在するのでしょうか？
また、アトミック処理以外にもロックフリーを実現することは可能なのでしょうか？？

**[疑問２]**
アトミック処理は、ロックを使用しないのに、どうやって排他的制御を実現しているのでしょうか？？
自分の予想なのですが・・・これってもしかしてCPUにアトミック専用命令みたいなものが用意されている？・・・のでしょうか？　EX : add命令　-> atomic.add命令　みたいな感じですかね。

---

ここから`volatile`が出てきます。

C++ストラウストラップ氏の本から以下抜粋です。
> アトミック処理は、メモリ状態が、指定したメモリオーダの要求通りとなることを保証する。
（メモリオーダーとは）コンパイラやオプティマイザはプログラムの実行速度向上を目的に、命令の順序を並べ替えることがある。
・・・　
もっとも単純なメモリオーダーは、逐次一貫と呼ばれるものだ。逐次一貫メモリモデルでは、すべてのスレッドは、実行されたすべての処理の結果が同じ順序として見える。その順序は、単一スレッドで命令を逐次実行した場合の順序である。
スレッドが命令の実行順序を変更することはあり得るが、他のスレッドが変数を参照する時点では、それまで実行された処理、及び（その結果である）メモリロケーションの値が的確に定義された状態であることが保証されて、全スレッドから同じものが見える。メモリロケーションに一貫した観点を強制した上で値を”見る”ことをアトミック処理と呼ぶ。

ふぅーーーー。ちょっと長いですね。
要は、命令順序は変更されることは、あっても変数内の値は、的確に定義された状態であることが保証されているということですよね。

では、ここで別の書籍のサンプルコードを見てみます。
```C++
volatile std::atomic_flag shared_lock;

void thread_function(int id){
   while(shared_lock.test_and_set())
      sleep(1);
   shared_data = id;
   std::cout << "Thread " << id << " set shared value to " << shared_data << std::endl;
   usleep(id * 100);
   std::cout << "Thread " << id << " has shared value as " << shared_data << std::endl;
   shared_lock.clear();
}
```
ん？？
`volatile`が出てきています。
[volatileが必要な場面を見つけ出す](https://teratail.com/questions/114172)

**[疑問３]**
このvolatileはどのような効果を持っているのでしょうか？
命令順序は変更されることは、あっても変数内の値は、的確に定義された状態であることはアトミックによって保証されているはずですよね。
これって、volatileの効果とかぶっていませんか？？

volatile変数は「コンパイラからは検知できない任意タイミングで更新される可能性のある変数」
スレッドには当てはまらない。はずです。
となると、このvolatileは命令の実行順序と関係がありそうですね。

**アトミックはvolatileの性質を含んでいるのでしょうか？？**

**[疑問４]**
アトミックとは別にvolatileによく似ているのが、メモリフェンス（メモリバリア）の存在です。

> CPUやコンパイラは、メモリフェンスを越えて読み込みと書き込みの操作の順序を入れ替えることができない。

> volatile宣言がされている場合、コンパイラはそのデータが置かれたメモリに対する読み書きの順序を変更できない。しかし、これらの読み書きと、他のメモリに対する読み書きとの順序を変更してもよい。

ん〜〜？？
なんか言っている事が同じ気がするんですが・・・
**volatileとメモリバリアの違いがハッキリしません。**

> アトミック処理は、メモリ状態が指定したメモリオーダーの要求通りとなる事を保証する。
デフォルトのメモリオーダーは、`memory_order_seq_cst`である。

例
```C++
int x = 0, y = 0, r1 = 0, r2 = 0;

// スレッド1
x = 1;
r1 = y;

// スレッド２
y = 1;
r2 = x;
```
> プログラム終了時、r1とr2の値はどちらも0になる可能性がある。この状況が発生するのは、スレッド２が１を代入する前にスレッド１がｙを読み込んでしまう場合、もしくはスレッド２はｙに１を代入したが、値がキャッシュされ、スレッド１がｙを読む際に値が反映されていない場合がある。
メモリバリアはこれらのデータ競合を緩和する低レベルな方法である。
次のコードはメモリフェンスを追加している。
```C++
int x = 0, y = 0, r1 = 0, r2 = 0;

//スレッド1
x = 1;
atomic_thread_fence(memory_order_seq_cst);
r1 = y;

//スレッド2
y = 1;
atomic_thread_fence(memory_order_seq_cst);
r2 = x;
```
これ、volatileではダメなんでしょうか？

**[疑問５]**
疑問２と似ているのですが・・・このメモリバリアと呼ばれるものはどうやって実現しているのでしょうか？
これも、CPUにメモリバリア専用命令みたいなのが用意されているのでしょうか？
メモリバリアの `atomic_thread_fence`の名前でatomicが付いているので、そうなのかなぁ〜〜という推測です。

疑問３と４は、アトミックとvolatileとメモリバリアの違いについての疑問です。
わかる方お願いします。

環境は、g++ Linux です。

**[追記]**
疑問３については、[volatileが必要な場面を見つけ出す](https://teratail.com/questions/114172)の中でChironianさんが触れていることに非常に近いですね。

> なるほど。そう言えば、関数呼び出しを挟めば最適化が抑止されたことがありました。そのように規定されているのですね！（lock()が同期用のロックかどうかコンパイラは把握できない筈ですし）
アトミック変数はどうでしょう？　必要に応じて暗黙的にvolatileになるのでしょうか？

アトミック変数がvolatileの性質を含んでいるような気がしますが・・・
質問中のコードにはなぜvolatileが登場しているんでしょうかね・・・

ミューテックスとアトミック処理について

C言語における構造体のアドレスについて教えていただきたいです。
下記コードのように構造体を作り、実体を作りました。
そのとき実体のアドレスを調べたところ、
どちら同じアドレスが表示されました。

なぜ同じアドレスが表示されるのでしょうか。
C言語の仕様上、この場合はsも&sも同じことを表すように
変換されているのですか？

調べてみましたが、よくわからなかったため、
質問をさせていただきました。

```
typdef struct{
    int a;
    int b;
    int c;
}SAMPLE;

int main(){
    SAMPLE s[3];
    printf("%p\n",s);
    printf("%p\n",&s);
    //どちらも同じアドレスが表示される
}
```

C言語における構造体のアドレスについて

C言語の本にこうありました。
> バイナリファイルに対してのメモリの内容をそのまま読み書きするときは、構造体のメンバの並びや境界調整に気をつける

おそらく、境界調整による**詰め物**を考慮せよということなのかな？
**直感的に詰め物がない構造体の方が良い**と思われます。
間違っていたらご指摘をお願いします。

というわけで、実際に作ってみました。
```C
struct test {
		char tt;
		int hj;
		char gh;
		char bn;
		//double nn;
	};
```
offsetof()によって各メンバ変数を確認しました。

char tt : 4byte
int hj  : 4byte
char gh : 1byte
char bn : 3byte

☆double 型のコメントを外すと、
char tt : 4byte
int hj  : 4byte
char gh : 1byte
char bn : 7byte
double nn : 8byte

**規則性**がよくわからないのですが・・・
double型なしの時は、gh+bnで4btyeとし、４の倍数として、境界調整されている感じです。
double型ありの時は、gh+bnで8byte, tt+hjで8byteなので、８の倍数で境界調整が行われている・・・のかな・・・

**メンバ変数の宣言の順番**によっても詰め物のバイト数が変わると予想しているのですが、
#これを、詰め物がない理想的な構造体にするには、どうすれば良いのでしょうか？？

**メンバ変数の中で最も大きな変数に境界調整は合わせられる**という理解で正しいでしょうか？？

構造体を作るときにいちいちoffsetofマクロでアライメントを確認するのが、非常に大変な作業なので、構造体を作るときにメンバ宣言のルールのようなものがありましたら、教えてください。

一応windows 64bitで実験しました。

> [追記]

Linux 64 bit でもっとメンバ変数を多くして実験してみたところ、
double, float, int, short, unsigned char, char
の順に下から大きい順に並べて構造体を作成してみたところ、gccコンパイラでのoffsetofの結果は、詰め物バイト数を最小にすることができました。
大きいバイト数から数えて（下から）、最大のバイト数の倍数（この場合、double型の8の倍数）になるように構造体の各メンバ変数を作成、調整をしていけば良さそうです。

どうしても、詰め物を入れざるを得ない状況（メンバ変数の全バイトが倍数にならない）で、詰め物を0byteにするのは実質、不可能なんでしょうか？

例えば、詰め物を0byteに出来るように、あえて使わないメンバ変数を作成し、0で初期化した場合、それをバイナリファイルへの出力としたら、中間に余計な0が入ってしまいます。
これでは、ダミー変数を用意しても詰め物と同じ結果になりませんか？

> [追記２]

[メンバの順序](http://www.google.co.jp/search?sourceid=navclient-ff&ie=UTF-8&rls=GGGL,GGGL:2006-34,GGGL:ja&q=%22%E6%A7%8B%E9%80%A0%E4%BD%93%22+%22%E3%83%A1%E3%83%B3%E3%83%90%E3%81%AE%E9%A0%86%E5%BA%8F%22+%22%EF%BC%A3%E8%A8%80%E8%AA%9E%22)

いろいろ出てきますが、**詰め物の最小化とメンバ変数の順序には関係性がありそうです。**
maismakunさんやケイロニアンさんの回答をもとにすると、CPUとメモリ、メモリと記憶装置、の両方とも理想的な構造体を作成するのは、難しいと思われます

64bit CPUに話を絞るのですが、8^2なので、実行単位は8byteだと思います。
構造体全体のサイズを8の倍数にし、さらに詰め物を最小にするような構造体の作成はやや大変だと思います。
メンバ変数の順序以外に理想形に近づける方法は他にありますでしょうか？

構造体のアライメント

他の言語では外部ファイルも同じ拡張子のソースコードでそれを読みこむのがありますよね。
C言語で拡張子が違くなっているのは何故ですか？

C言語の.cファイルと.hファイルに違いはありますか？

C言語で複数の数値データを圧縮してバイト数を減らすことを考えています。
例えば、6bit(0-63)のデータ4つを3byteのデータとして送信する場合、
以下のような方法が考えられます。
```
//数値データ
int data[4] = {10, 20, 40, 60};
uint8_t compData[3] = {0};

comData[0]  = data[0] << 2 | data[1] >> 4;

comData[1]  = data[1] << 4 | data[2] >> 2;

comData[2]  = data[2] << 6 | data[3];
```
既存のライブラリや、より簡単な方法があれば教えて頂きたく。

*失礼しました。上記だとuint32_tのデータに入れればよいという事になりそうですが、
よりデータ量が多い場合に対処する方法があるかを把握したいです。
現在直面している課題は合計10以上の異なるbit数からなる全128bitのデータを
16byteにまとめたいと考えています。

例えば1Byteデータを16個並べた型をtypedefで生成して、
その型に各データをbitシフトするという方法がとれるなら多少楽になるかと思いましたが、
16byteの型というものは生成可能なのでしょうか。

複数の数値データを圧縮してバイト数を減らしたい

先日、webアプリケーションを個人の案件として、実装し運営を行っていたのですが、同僚からその案や機能を真似されました。

コードそのものの盗用ではないので、なかなか主張できないところではあるのですが、今後もその様なことを考えると、対策しないといけないと思い、コーディング規約を作成したいのですが、皆さんはどの様な権利を主張しますか？

また、このように直接的でなくても、企画や機能、デザインを真似された場合どの様に対処、対応しますか？

関係のない質問となりましたが、ご教示お願いします。

コードに関する著作権について

rails sで立ち上げる仮想サーバーと、Apacheでは何が違うのでしょうか。

両方サーバーの役割を担っているようですが、違いがよくわかりません。

rails s と Apache

CentOS8 
Windows7
linux8.1.1911
VirtualBox-6.1.4-136177-Win.exe

自宅でVirtualBoxを使用したいのですが
[root@localhost]#sudo yum upgrade 
とするとsudo. /usr/bin/yum --helpを使用してください。DNFプラグインコマンドかもしれません。"dnf install 'dnf-command(sudo)' "を試してください
と表示された為試したところ、repo 'Appstream'のメタデータのダウンロードに失敗しました。エラー:repo 'Appstream'のメタデータのダウンロードに失敗しました。
と表示されました。。
ネットワークに接続されていないのかも。。
という考えにまでは至りネットで調べたのですが、わたしの知識不足で何をすれば良いのか、、全く分からず、、
どなたか分かりやすく教えてくださると助かります。宜しくお願い致します。。

CentOS8 ネットワークに繋がらない

リンカとはosに依存するツールだと書いてあったのですが、いまいちリンカが何なのかわかりません。
リンカがソフトとも書いてありましたが、Ｃ言語をコンパイルしてアセンブリプログラムをアセンブルする過程でリンカが働いているのでしょうか？
リンカと調べるとリンカスクリプトと出てきてリンカについての情報が曖昧です。
どうかリンカが何なのか教えて頂けないでしょうか？
アセンブリ言語とは直接でないにしても関係のあるような記事はいくつかありました。
アセンブリプログラムのアセンブル(アセンブリ用のコンパイラ)がリンカなのでしょうか？

編集
図書館で調べたり、書店で立ち読みしたり、サイトで調べた結果。
Linuxで複数のアセンブリプログラムを一つにするのかに、リンカが必要だそうですが、リンカを使わないで、複数のアセンブリプログラムを一つにまとめて見ます。これに関してはリンカ自体を手作業でやるようなものであり、何ヶ月、何年かかるかわかりませんが。好奇心が満たせるなら行いたいです。
また、一つにしたアセンブリプログラムをメモリに入れる際のメモリの指定も自分でやってみます。
リンカの行なっていることを手作業でやることで、知識が深まると思います。
また、アセンブリプログラムを機械語に変換するのに、リンカが関係ないこともわかりました。
なぜなら、複数のアセンブリプログラムを一つにするのがリンカ
の役割で、その一つにしたアセンブリプログラムをメモリに収納するまでが、リンカの仕事で、あとはアセンブルが単純にアセンブリ命令に対応した機械語を出力するだけですので。
確認として以上の認識であっていますか？間違っていたら怖いのでお願いいたします。
まぁ、以上の話からアセンブリプログラムを機械語に変化するアセンブラにはリンカが必要ないと書いてありました。また、リンカはあくまて複数のアセンブリプログラムを一つにするためにアセンブリプログラムのアドレスを基に複数のアセンブリプログラムを一つにするとも書いてありました。念のため確認します。

編集2
度々、すいません、

オブジェクトファイルにcpuに繋がる外部装置や、複数のアセンブリプログラムを一つにする為のアドレスやメモリ状況がわかるでしょうか？ならば、
オブジェクトファイルをアセンブリやニーモニックに変換するソフトを使えば、複数のアセンブリプログラムを一つにする方法や情報が書いてあるのでしょうか？

リンカの働き、アセンブリプログラムをアセンブルにより機械語に変換する。

### 前提・実現したいこと
リンカスクリプトを用いたリンクに失敗します。
```
表示されるエラー
kernel.o: In function `_kernel_entry':
KERNEL.c:(.text+0x5): undefined reference to `_BSS_START'
KERNEL.c:(.text+0xa): undefined reference to `_BSS_END'
KERNEL.c:(.text+0x13): undefined reference to `initBSS'
```

```c
KERNEL.c

#include "include/section.h"
#include "include/memory.h"

int _kernel_entry( void ){
    initBSS( _BSS_START, _BSS_END - _BSS_START );
	for( ;; )
	{
	}
}
```

```
section.h

extern unsigned int _TEXT_START;
extern unsigned int _TEXT_END;
extern unsigned int _BSS_START;
extern unsigned int _BSS_END;
```

```c
section.c

unsigned int _TEXT_START 	= ( unsigned int )&_text_start;
unsigned int _TEXT_END 		= ( unsigned int )&_text_end;
unsigned int _BSS_START		= ( unsigned int )&_bss_start;
unsigned int _BSS_END 		= ( unsigned int )&_bss_end;
```

```
memory.h

void initBSS( unsigned int kernel_bss_start, int size );```
```

```c
memory.c

#include "kstdlib.h"
void initBSS( unsigned int kernel_bss_start, int size ){
	kmemset( ( void * )kernel_bss_start, 0x00, size );
}
```

```
kstdlib.h

void kmemset(void *str,unsigned char c,int size);
```

```c
kstdlib.c

void kmemset(void *str,unsigned char c,int size){
  unsigned char *ptr = (unsigned char*)str;
  const unsigned char ch = (const unsigned char)c;
  while(size--){
    *ptr++=ch;
  }
}
```

```
リンカスクリプト(linker.link)
SECTIONS
{
    . = 0x100000;
    .text :
    {
        _text_start = .;
        *(.text)
        _text_end = .;
    }

    .rodata :
    {
        _rodata_start = .;
        *(.rodata)
        _rodata_end = .;
    }

    .data :
    {
        _data_start = .;
        *(.data)
        _data_end = .;
    }

    .bss :
    {
        _bss_start = .;
        *(.bss)
        _bss_end = .;
    }
}
```

### 試したこと

フォルダの構成は、現在のフォルダにKERNEL.cとリンカスクリプトとincludeフォルダがあり、includeフォルダの中にmemory.c,memory.h,section.c,section.h,kstdlib.c,kstdlib.hがある状態です。
現在のフォルダにいる状態で、
i386-elf-gcc -c -o kernel.o KERNEL.c -O2 -I /include -Wall
とコンパイルしました。その後、
i386-elf-ld -T linker.link -Map kernel.map -nostdlib -e _kernel_entry
--oformat binary -o KIMAGE kernel.o
とリンクしたところ最初に書いたエラーが出てしまいリンクできません。
memory.cをオブジェクトファイルにしなければならないのかなと思いましたが、
リンカスクリプトのシンボルを参照しているためそれも出来そうになく困っています。

### 補足情報（FW/ツールのバージョンなど）

macOS high sierra
gcc version 6.5.0 (GCC)
GNU ld (GNU Binutils) 2.28
### 追記
section.cをコンパイルしてオブジェクトファイルに出来ず、
error: '_text_start' undeclared here
というエラーを吐いてしまいます。
この_text_startですが、これはリンカスクリプト内で定義しているはずなのですが・・・。

リンカスクリプトを用いたリンクに失敗する。undefined reference

Linuxカーネルのソースコードを眺めているをよく出てくる書き方があります

**1,** これは・・・名前にシャープを付けているんでしょうか？
関数の方にも使用できるんですか？
```C
#define SYS_ify(syscall_name)   __NR_##syscall_name

LOAD_ARGS_TYPES_##nr (args) 
```

**2,** プリプロセッサの[!]はC言語の[!]と同じ意味です？？
```C
#if !defined __NR_pread && defined __NR_pread64
```

**3, **インラインアセンブリではなく、アセンブリ言語をC言語と混合して使用している？
そんなこと可能なんですか？
後ろのバックスラッシュが気になりますね。
```ここに言語を入力
# define PSEUDO(name, syscall_name, args)                                     \
  .text;                                                                      \
  ENTRY (name)                                                                \
    DO_CALL (syscall_name, args);                                             \
    cmpq $-4095, %rax;                                                        \
    jae SYSCALL_ERROR_LABEL
```

**4,** 中括弧を大括弧で囲んでいる？
これは・・・関数の定義ですか？それともマクロですか？ 融合しているような・・・
よく見ると可変長関数ですかね？ 関数内部では可変長用の処理が行われていないような・・・
```ここに言語を入力
# define INLINE_SYSCALL_TYPES(name, nr, args...) \
  ({                                                                          \
    unsigned long int resultvar = INTERNAL_SYSCALL_TYPES (name, , nr, args);  \
    if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, )))            \
      {                                                                       \
        __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, ));                   \
        resultvar = (unsigned long int) -1;                                   \
      }                                                                       \
    (long int) resultvar; })
```

**5,** 関数の中に関数を定義 ＆ 呼び出しているんでしょうか？？
list_for_each_entry（）の箇所ですね。
(ちょっと長いので省略しています。)
```ここに言語を入力
int search_binary_handler(struct linux_binprm *bprm)                     
{                                   
        bool need_retry = IS_ENABLED(CONFIG_MODULES);                    
        struct linux_binfmt *fmt;   
        int retval;                 

        /* This allows 4 levels of binfmt rewrites before failing hard. */                                                                         
        if (bprm->recursion_depth > 5)                                   
                return -ELOOP;      

        retval = security_bprm_check(bprm);                              
        if (retval)                 
                return retval;      

        retval = -ENOENT;           
 retry:                             
        read_lock(&binfmt_lock);    
        list_for_each_entry(fmt, &formats, lh) {                         
                if (!try_module_get(fmt->module))                        
                        continue;   
                read_unlock(&binfmt_lock);                               
                bprm->recursion_depth++;                                 
                retval = fmt->load_binary(bprm);                         
                read_lock(&binfmt_lock);                                 
                put_binfmt(fmt);    
                bprm->recursion_depth--;                                 
                if (retval < 0 && !bprm->mm) {         

・・・
```

どれも標準のC言語では、出てこないような・・・・
見たことのない記述の仕方です。
ちなみに拡張子にcppと付いていないので、C++ではない・・・かな？
と思うのですが・・・

わかる方いましたら教えてください。

[追記]
3番について補足です。
```ここに言語を入力
# ifdef PIC
#  define SYSCALL_ERROR_LABEL 0f
# else
#  define SYSCALL_ERROR_LABEL syscall_error
# endif

# undef PSEUDO
# define PSEUDO(name, syscall_name, args)                                     \
  .text;                                                                      \
  ENTRY (name)                                                                \
    DO_CALL (syscall_name, args);                                             \
    cmpq $-4095, %rax;                                                        \
    jae SYSCALL_ERROR_LABEL

# undef PSEUDO_END
# define PSEUDO_END(name)                                                     \
  SYSCALL_ERROR_HANDLER                                                       \
  END (name)
```
となっていまいました。

ENTRY()とEND()に挟まれている部分にアセンブリ言語が記述されています。