12.C - YukaKoshiba/MyknowledgeDocs GitHub Wiki

int main(void){
  // 処理を記述
return 0; // 正常に終了
}

int main(int argc, char *argv[]){
  // 処理を記述
return 0; // 正常に終了
}

int main(int argc, char *argv[]) {
    // write program process
}

// command
./myprogram John

// Set option
char *optionName = "begr"; // Accept only b,e,g,r
// Analyze command line arguments and return results
char variable = getopt(argc, argv, optionName);

#include <stdio.h> // Library providing standard input/output functionality
#include <math.h>  // Libraries that provide mathematical functionality

// import the library providing standard input/output functionality
#include <stdio.h>
int main(void){
printf("hello, world\n");
}

#include <stdio.h>

int main(void){
    string name = get_string("What's your name?\n ");
    int age = get_int("What's your age?\n ");

    printf("hello, %s\n", name);
    printf("your age: %d\n", age);
}

// Only one line of comment
/*
*Multi-line comments
*/

int num = 10;

#include <stdio.h>

int main(int argc, char** argv){
	printf("Hello,%s. Your age is %d.\n", "Tomy", 20);
	printf("Your nickname is %c. \n", 'Tom');
	printf("%lf + %lf = %lf\n", 1.2, 2.7, 1.2 + 2.7);
    return 0;
}

typedef 元のデータ型 新しい名前;

// unsigned char を byte という名前で使えるようにする
typedef unsigned char byte;
// byte 型の変数 myByte を宣言
byte myByte = 255;

// 配列の宣言
int numbers[5]; // 整数を5個格納できる配列
// 値の挿入または初期化
numbers[0] = 2;
numbers[1] = 10; 

// 配列の宣言と同時に初期化
int scores[5] = {80, 90, 75, 60, 100};

// 配列の宣言と同時にすべての要素を同じ値で初期化
int scores[5] = {10};

// 配列のデータを別の配列へコピーする
int numDatas[3] = {1, 5, 8};
int numDatasNew[3]:

// numDatasNew = numDatasという代入は出来ない
for (int i; i < 3, i++) {
  numDatas[i] = numDatasNew[i];
}

// コマンドライン引数の1つ目の引数であるargv[1]のi番目の文字が'\0'(ヌル文字)ではない
int main(int argc, string argv[])
{
  // argv[1]のi番目の文字が'\0'(ヌル文字)ではない
  if (argv[1][i] != '\0') {
    // 処理を記述
  }
}

#include <stdlib.h>
// ユーザが入力したinputに応じて、textの文字列(=文字の配列)を動的に設定する
string input= get_string("plaintext: ");
string text = malloc((strlen(plaintext) + 1) * (char));
// 最後に動的メモリの解放
free(text);

#include <stdio.h>
int main(void)
{
int x = 1;
int y = 2;
// Check whether agreed
if (x > Y) {
    printf("x is greater than y.\n");
} else if (x == y) {
    printf("x is equal to y.\n");
} else {
    printf("x is not greater than y.\n");
}

}

#include <stdio.h>
int main(void)
{
  for (int i = 0; i < 3; i++) {
    printf("Hello!\n");
  }
}

#include <stdio.h>

int i = 3;
while (i > 0)
{
  printf("hello!\n");
  i--;
}

// create function
bool isPositive(int num) {
  // return bool type data
  return num > 0;
}
// call created function
int main() {
int number = -5;
if (isPositive(number)) {
std::cout << number << "is positive. \n";
} else {
std::cout << number << "isn't positive.\n";
}
return 0;
}

#include <stdio.h>
// プロトタイプ宣言
int add(int a, int b);
int main(void) {
int x = 5;
int y = 3;
int sum = add(x, y);
printf("和: %d\n", sum);

return 0;

}
// 関数の定義
int add(int a, int b) {
return a + b;
}

int x = 10;

// ポインタ演算子pを初期化
int *p = NULL;
// 変数 x のアドレスをポインタ(メモリのアドレスを格納する変数)p に格納
*p = &x;

int x = 10;
// 変数 x のアドレスをポインタ(メモリのアドレスを格納する変数)p に格納
int *p = &x;
printf("%d\n", *p); // 10
*p = 20;
printf("%d\n", x); // 20

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Linked Listのノードの構造体
struct Node {
int data;
struct Node *next;
} node;
int main() {
// 最初のノードを作成
node *head = (node *)malloc(sizeof(node));
head->data = 1;
head->next = NULL;
// 2番目のノードを作成し、リストに追加
node*second = (node)malloc(sizeof(node));
second->data = 2;
second->next = NULL;
head->next = second; // 最初のノードから2番目のノードへのリンクを作成

// 3番目のノードを作成し、リストに追加
node *third = (node *)malloc(sizeof(node));
third->data = 3;
third->next = NULL;
second->next = third; // 2番目のノードから3番目のノードへのリンクを作成

// リストを走査してデータを出力
node *current = head;
while (current != NULL) {
    printf("%d\n", current->data);
    current = current->next; // 次のノードへ移動
}

// メモリ解放（省略）
return 0;

}

// 8bit(符号なし/負ではない)整数を格納する配列headerを宣言する(=バッファを確保する)
uint8_t header[44]; // 要素数 44
// 16it(符号あり/正と負)整数を格納する配列headerを宣言する(=バッファを確保する)
int16_t header[44]; // 要素数 44

#include <stdio.h>
int main() {
FILE *fp;
char c;
// ファイルを書き込みモードで開く
fp = fopen("test.txt", "w");
if (fp == NULL) {
    printf("ファイルを開けませんでした。\n");
    return 1;
}

// ファイルに文字列を書き込む
fputs("Hello, world!\n", fp);

// ファイルを閉じる
fclose(fp);

// ファイルを読み込みモードで開く
fp = fopen("test.txt", "r");
if (fp == NULL) {
    printf("ファイルを開けませんでした。\n");
    return 1;
}

// ファイルから1文字ずつ読み込んで表示する
while ((c = fgetc(fp)) != EOF) {
    putchar(c);
}

// ファイルを閉じる
fclose(fp);

return 0;

}

// ファイルの読み込み
#include <stdio.h>
fread(格納先のメモリアドレス, 読み込みデータのbyte数, 一度に読み込むデータの種類の数, fopenで開いた読み込みファイル);

// ファイルの読み込み
#include <stdio.h>
fscanf(ファイルポインタ, 書式指定文字列, 変数のアドレス, ...)

// ファイルから整数と文字列をカンマ区切りで読み込む
fscanf(fp, "%d,%s", &num, str);

// ファイルの書き込み
#include <stdio.h>
fwrite(データを取得する格納先のメモリアドレス, 書き込み込みデータのbyte数, 一度に読み込むデータの種類の数, fopenで開いた読み込み先ファイル);

// myheader.h
#ifndef MYHEADER_H
#define MYHEADER_H
// 関数のプロトタイプ宣言
int add(int a, int b);
// 構造体の定義
typedef struct {
int x;
int y;
} Point;
// マクロ定義
#define PI 3.14159
#endif

// myprogram.c
#include "myheader.h"
#include 
int main() {
// 処理を記述
return 0;
}

// MYHEADER_Hというマクロが定義されているかどうかを#ifndefでチェックする
// 2回目以降の読み込みでは、MYHEADER_Hが既に定義されているため、#ifndefの条件が偽となり、ヘッダーファイルの内容は無視される
#ifndef MYHEADER_H
// もしMYHEADER_Hが定義されていなければ、#define MYHEADER_HによってMYHEADER_Hを定義し、ヘッダーファイルの内容を有効にする
#define MYHEADER_H
// ヘッダーファイルの内容（関数プロトタイプ宣言、構造体定義など）
#endif

struct 構造体名 {
    型名 メンバ1;
    型名 メンバ2;
    ...
};

typedef struct 構造体名{ // 構造体名は無くても可
    型名 メンバ1;
    型名 メンバ2;
    ...
} 構造体の省略名;

struct 構造体名 変数名;
// typedefを使用(構造体の省略名を付与)している場合
構造体の省略名 変数名;

変数名.メンバ名

struct node {
    int data;          // データ（例：整数）
    struct node *next; // 次のノードへのポインタ
} node;

#include <stdio.h>
#include <stdlib.h>
// ノードをリストの先頭に追加する関数
node *addNode(node *head, int data) {
node *newNode = (node *)malloc(sizeof(node));
if (newNode == NULL) {
printf("メモリ割り当てエラー\n");
return head;
}
newNode->data = data;
newNode->next = head;
return newNode;
}
// リストの要素を表示する関数
void displayList(node *head) {
node *current = head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}
int main() {
node *head = NULL; // 空のリストを作成
head = addNode(head, 3);
head = addNode(head, 7);
head = addNode(head, 1);

displayList(head); // リストを表示

// メモリ解放
node *current = head;
while (current != NULL) {
    node *temp = current;
    current = current->next;
    free(temp);
}
head = NULL; // リストの先頭ポインタをNULLに設定

return 0;

}

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *prev; // 次のノードへのポインタ
struct Node *next; // 前のノードへのポインタ
} node;

// 新しいノードを作成する関数
Node *createNode(int data) {
    node *newNode = (node *)malloc(sizeof(node));
    if (newNode == NULL) {
        printf("メモリ割り当てエラー\n");
        return NULL;
    }
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// リストの先頭にノードを追加する関数
node *insertAtBeginning(node *head, int data) {
    node *newNode = createNode(data);
    if (newNode == NULL) {
        return head;
    }
    if (head == NULL) {
        return newNode;
    }
    newNode->next = head;
    head->prev = newNode;
    return newNode;
}

// リストの末尾にノードを追加する関数
node *insertAtEnd(node *head, int data) {
    node *newNode = createNode(data);
    if (newNode == NULL) {
        return head;
    }
    if (head == NULL) {
        return newNode;
    }
    node *current = head;
    while (current->next != NULL) {
        current = current->next;
    }
    current->next = newNode;
    newNode->prev = current;
    return head;
}

// リストからノードを削除する関数
node *deleteNode(node *head, node *target) {
    if (head == NULL || target == NULL) {
        return head;
    }
    if (target->prev != NULL) {
        target->prev->next = target->next;
    } else {
        head = target->next;
    }
    if (target->next != NULL) {
        target->next->prev = target->prev;
    }
    free(target);
    return head;
}

// リストの要素を表示する関数
void displayList(node *head) {
    node *current = head;
    while (current != NULL) {
        printf("%d <-> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// リストのメモリを解放する関数
void freeList(node *head) {
    node *current = head;
    while (current != NULL) {
        node *temp = current;
        current = current->next;
        free(temp);
    }
}

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 10 // スタックの最大サイズ
typedef struct {
int data[MAX_SIZE];
int top; // スタックの最上部を示すインデックス
} Stack;
// スタックを初期化する関数
void initialize(Stack *stack) {
stack->top = -1;
}
// スタックが空かどうかを判定する関数
int isEmpty(Stack *stack) {
return stack->top == -1;
}
// スタックが満杯かどうかを判定する関数
int isFull(Stack *stack) {
return stack->top == MAX_SIZE - 1;
}
// スタックに要素をプッシュする関数
void push(Stack *stack, int value) {
if (isFull(stack)) {
printf("スタックが満杯です。\n");
return;
}
stack->data[++stack->top] = value;
}
// スタックから要素をポップする関数
int pop(Stack *stack) {
if (isEmpty(stack)) {
printf("スタックが空です。\n");
return -1; // エラー値を返す
}
return stack->data[stack->top--];
}
int main() {
Stack stack;
initialize(&stack);
push(&stack, 1);
push(&stack, 2);
push(&stack, 3);

printf("ポップされた要素: %d\n", pop(&stack));
printf("ポップされた要素: %d\n", pop(&stack));

return 0;

}

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *next;
} Node;
typedef struct {
Node *front; // キューの先頭を示すポインタ
Node *rear;  // キューの末尾を示すポインタ
int val;
} Queue;
// キューを初期化する関数
void initializeQueue(Queue *queue) {
queue->front = NULL;
queue->rear = NULL;
}
// キューが空かどうかを判定する関数
int isEmptyQueue(Queue *queue) {
return queue->front == NULL;
}
// キューに要素をエンキューする関数
void enqueue(Queue *queue, int data) {
Node *newNode = (Node *)malloc(sizeof(Node));
if (newNode == NULL) {
printf("メモリ割り当てエラー\n");
return;
}
newNode->data = data;
newNode->next = NULL;
if (isEmptyQueue(queue)) {
    queue->front = newNode;
    queue->rear = newNode;
} else {
    queue->rear->next = newNode;
    queue->rear = newNode;
}

}
// キューから要素をデキューする関数
int dequeue(Queue *queue) {
if (isEmptyQueue(queue)) {
printf("キューは空です\n");
return -1; // エラー値を返す
}
Node *temp = queue->front;
int data = temp->data;

queue->front = queue->front->next;
if (queue->front == NULL) {
    queue->rear = NULL;
}

free(temp);
return data;

}
// キューの要素を表示する関数
void displayQueue(Queue *queue) {
Node *current = queue->front;
if (isEmptyQueue(queue)) {
printf("キューは空です\n");
return;
}
printf("キューの要素: ");
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}
int main() {
Queue queue;
initializeQueue(&queue);
enqueue(&queue, 1);
enqueue(&queue, 2);
enqueue(&queue, 3);

displayQueue(&queue);

printf("デキューされた要素: %d\n", dequeue(&queue));
displayQueue(&queue);

printf("デキューされた要素: %d\n", dequeue(&queue));
displayQueue(&queue);

printf("デキューされた要素: %d\n", dequeue(&queue));
displayQueue(&queue);

printf("デキューされた要素: %d\n", dequeue(&queue));

return 0;

}

// 構造体の定義
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TABLE_SIZE 10 // ハッシュテーブルのサイズ
typedef struct Node {
char *key;
int value;
struct Node *next;
} Node;
typedef struct {
Node *table[TABLE_SIZE];
} HashTable;
// ハッシュ関数の実装
unsigned int hash(char *key) {
unsigned int hash = 0;
for (int i = 0; key[i] != '\0'; i++) {
hash = 31 * hash + key[i];
}
return hash % TABLE_SIZE;
}
// ハッシュテーブルに要素を挿入する関数
void insert(HashTable *ht, char *key, int value) {
unsigned int index = hash(key);
Node *newNode = (Node *)malloc(sizeof(Node));
if (newNode == NULL) {
printf("メモリ割り当てエラー\n");
return;
}
newNode->key = strdup(key); // キーのコピーを保存
newNode->value = value;
newNode->next = ht->table[index];
ht->table[index] = newNode;
}
// ハッシュテーブルから要素を検索する関数
Node *search(HashTable *ht, char *key) {
unsigned int index = hash(key);
Node *current = ht->table[index];
while (current != NULL) {
if (strcmp(current->key, key) == 0) {
return current;
}
current = current->next;
}
return NULL; // 見つからなかった場合
}
// ハッシュテーブルから要素を削除する関数
void delete(HashTable *ht, char *key) {
unsigned int index = hash(key);
Node *current = ht->table[index];
Node *prev = NULL;
while (current != NULL) {
if (strcmp(current->key, key) == 0) {
if (prev == NULL) {
ht->table[index] = current->next;
} else {
prev->next = current->next;
}
free(current->key); // キーのメモリ解放
free(current);
return;
}
prev = current;
current = current->next;
}
}
int main() {
HashTable ht;
initHashTable(&ht);
insert(&ht, "apple", 1);
insert(&ht, "banana", 2);
insert(&ht, "orange", 3);

Node *result = search(&ht, "banana");
if (result != NULL) {
    printf("キー: %s, 値: %d\n", result->key, result->value);
} else {
    printf("キーが見つかりません\n");
}

delete(&ht, "banana");

result = search(&ht, "banana");
if (result == NULL) {
    printf("キー: banana は削除されました\n");
}

return 0;

}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define ALPHABET_SIZE 26 // アルファベットの文字数
typedef struct TrieNode {
struct TrieNode *children[ALPHABET_SIZE];
bool isEndOfWord; // 単語の末尾かどうか
} TrieNode;
// 新しいトライノードを作成する関数
TrieNode *createNode() {
TrieNode *newNode = (TrieNode *)malloc(sizeof(TrieNode));
if (newNode == NULL) {
printf("メモリ割り当てエラー\n");
return NULL;
}
newNode->isEndOfWord = false;
for (int i = 0; i < ALPHABET_SIZE; i++) {
newNode->children[i] = NULL;
}
return newNode;
}
// 文字からインデックスへの変換
int charToIndex(char c) {
return c - 'a';
}
// トライに単語を挿入する関数
void insert(TrieNode *root, char *word) {
TrieNode *current = root;
for (int i = 0; word[i] != '\0'; i++) {
int index = charToIndex(word[i]);
if (current->children[index] == NULL) {
current->children[index] = createNode();
}
current = current->children[index];
}
current->isEndOfWord = true;
}
// トライから単語を検索する関数
bool search(TrieNode *root, char *word) {
TrieNode *current = root;
for (int i = 0; word[i] != '\0'; i++) {
int index = charToIndex(word[i]);
if (current->children[index] == NULL) {
return false;
}
current = current->children[index];
}
return current->isEndOfWord;
}
int main() {
TrieNode *root = createNode();
insert(root, "apple");
insert(root, "banana");
insert(root, "orange");

printf("apple: %s\n", search(root, "apple") ? "見つかりました" : "見つかりません");
printf("grape: %s\n", search(root, "grape") ? "見つかりました" : "見つかりません");

return 0;

}