dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-mongodb-test'
    // 他省略
}

spring.mongodb.uri=mongodb://localhost:27017/demo?directConnection=true

package com.example.demo.models;

import java.time.LocalDateTime;
import org.springframework.data.mongodb.core.mapping.Document;
import lombok.Data;

// ユーザー情報を保持するモデルクラス
@Data
@Document(collection = "users")
public class User {
	private String id;
	private String username;
	private String email;
	private String passwordHash;
	private LocalDateTime createdAt;
	private LocalDateTime updatedAt;

	public User() {
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}

	public User(String username) {
		this.username = username;
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}
}

package com.example.demo.repository;

import java.util.List;
import com.example.demo.models.User;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
  public List<User> findByUsername(String username);
}

package com.example.demo;

import com.example.demo.models.User;
import com.example.demo.repository.UserRepository;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/hello")
    public String hello() {
        // ユーザーコレクションをクリアしてから新しいユーザーを保存
        userRepository.deleteAll();
        userRepository.save(new User("n-ozawan"));

        // "n-ozawan" というユーザー名でユーザーを検索
        List<User> users = userRepository.findByUsername("n-ozawan");

        // 検索結果を文字列に変換して返す
        return users.stream()
                .map(User::toString)
                .collect(Collectors.joining(", "));
    }
}

[
  {
    _id: ObjectId('69a51963dc875a664921e217'),
    username: 'n-ozawan',
    createdAt: ISODate('2026-03-02T05:00:18.977Z'),
    updatedAt: ISODate('2026-03-02T05:00:18.977Z'),
    _class: 'com.example.demo.models.User'
  }
]

package com.example.demo;

import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.bson.Document;
import org.springframework.data.mongodb.core.query.Query;
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

@RestController
public class Hello2Controller {

    @Autowired
    private MongoTemplate mongoTemplate;

    @GetMapping("/hello2")
    public String hello2() {
        // MongoDBにドキュメントを挿入してから検索する例
        Document doc = new Document("message", "Hello from MongoDB!")
            .append("hoge", new Document("fuga", 123));

        // コレクションを一旦クリアしてから新しいドキュメントを挿入
        mongoTemplate.dropCollection("greetings");
        mongoTemplate.insert(doc, "greetings");

        // "message" フィールドが "Hello from MongoDB!" であるドキュメントを検索
        Query query = query(where("message").is("Hello from MongoDB!"));
        query.fields().include("message").exclude("_id");
        List<Document> documents = mongoTemplate.query(Document.class)
                .inCollection("greetings")
                .matching(query).all();

        // 検索結果を文字列に変換して返す
        return documents.stream()
                .map(Document::toJson)
                .collect(Collectors.joining(", "));
    }
}

uint32_t x = 0x00F0u;
printf("x = 0x%08X (%032b)\n", x, x);   // 0x000000F0 (00000000000000000000000011110000)
printf("stdc_count_ones(x)      = %d\n", stdc_count_ones(x));       // 4
printf("stdc_count_zeros(x)     = %d\n", stdc_count_zeros(x));      // 28

uint32_t x1 = 0xF00000FFu;
printf("x = 0x%08X (%032b)\n", x1, x1);   // 0xF00000FF (11110000000000000000000011111111)
printf("stdc_leading_ones(x1)   = %d\n", stdc_leading_ones(x1));     // 4
printf("stdc_trailing_ones(x1)  = %d\n", stdc_trailing_ones(x1));    // 8
printf("stdc_leading_zeros(x1)  = %d\n", stdc_leading_zeros(x1));    // 0
printf("stdc_trailing_zeros(x1) = %d\n", stdc_trailing_zeros(x1));   // 0

uint32_t x2 = 0x00F0u;
printf("x = 0x%08X (%032b)\n", x2, x2);   // 0x000000F0 (00000000000000000000000011110000)
printf("stdc_leading_ones(x2)   = %d\n", stdc_leading_ones(x2));     // 0
printf("stdc_trailing_ones(x2)  = %d\n", stdc_trailing_ones(x2));    // 0
printf("stdc_leading_zeros(x2)  = %d\n", stdc_leading_zeros(x2));    // 24
printf("stdc_trailing_zeros(x2) = %d\n", stdc_trailing_zeros(x2));   // 4

uint32_t x1 = 0x00400000u;
printf("x = 0x%08X (%032b)\n", x1, x1);   // 0x00400000 (00000000010000000000000000000000)
printf("stdc_first_leading_one(x1)   = %d\n", stdc_first_leading_one(x1));     // 10
printf("stdc_first_trailing_one(x1)  = %d\n", stdc_first_trailing_one(x1));    // 23
printf("stdc_first_leading_zero(x1)  = %d\n", stdc_first_leading_zero(x1));    // 1
printf("stdc_first_trailing_zero(x1) = %d\n", stdc_first_trailing_zero(x1));   // 1

uint32_t x2 = 0xFFFFEFFFu;
printf("x = 0x%08X (%032b)\n", x2, x2);   // 0xFFFFEFFF (11111111111111111110111111111111)
printf("stdc_first_leading_one(x2)   = %d\n", stdc_first_leading_one(x2));     // 1
printf("stdc_first_trailing_one(x2)  = %d\n", stdc_first_trailing_one(x2));    // 1
printf("stdc_first_leading_zero(x2)  = %d\n", stdc_first_leading_zero(x2));    // 20
printf("stdc_first_trailing_zero(x2) = %d\n", stdc_first_trailing_zero(x2));   // 13

uint8_t samples[] = {0u, 1u, 2u, 3u, 4u, 7u, 8u, 16u};
for (size_t i = 0; i < sizeof(samples)/sizeof(samples[0]); ++i) {
  uint8_t v = samples[i];
  printf("v=0x%02X(%08b): has_single_bit=%d\n", v, v, stdc_has_single_bit(v));
}

// v=0x00(00000000): has_single_bit=0
// v=0x01(00000001): has_single_bit=1
// v=0x02(00000010): has_single_bit=1
// v=0x03(00000011): has_single_bit=0
// v=0x04(00000100): has_single_bit=1
// v=0x07(00000111): has_single_bit=0
// v=0x08(00001000): has_single_bit=1
// v=0x10(00010000): has_single_bit=1

uint8_t samples[] = {0u, 1u, 2u, 3u, 4u, 7u, 8u, 16u};
for (size_t i = 0; i < sizeof(samples)/sizeof(samples[0]); ++i) {
  uint8_t v = samples[i];
  printf("v=0x%02X(%08b): bit_floor=0x%02X, bit_ceil=0x%02X\n",
          v, v, stdc_bit_floor(v), stdc_bit_ceil(v));
}

// v=0x00(00000000): bit_floor=0x00, bit_ceil=0x01
// v=0x01(00000001): bit_floor=0x01, bit_ceil=0x01
// v=0x02(00000010): bit_floor=0x02, bit_ceil=0x02
// v=0x03(00000011): bit_floor=0x02, bit_ceil=0x04
// v=0x04(00000100): bit_floor=0x04, bit_ceil=0x04
// v=0x07(00000111): bit_floor=0x04, bit_ceil=0x08
// v=0x08(00001000): bit_floor=0x08, bit_ceil=0x08
// v=0x10(00010000): bit_floor=0x10, bit_ceil=0x10

uint8_t samples[] = {0u, 1u, 2u, 3u, 4u, 7u, 8u, 16u, 31u, 32u, 63u, 64u};
for (size_t i = 0; i < sizeof(samples)/sizeof(samples[0]); ++i) {
  uint8_t v = samples[i];
  printf("v=0x%02X(%08b): bit_width=%d\n", v, v, stdc_bit_width(v));
}

// v=0x00(00000000): bit_width=0
// v=0x01(00000001): bit_width=1
// v=0x02(00000010): bit_width=2
// v=0x03(00000011): bit_width=2
// v=0x04(00000100): bit_width=3
// v=0x07(00000111): bit_width=3
// v=0x08(00001000): bit_width=4
// v=0x10(00010000): bit_width=5
// v=0x1F(00011111): bit_width=5
// v=0x20(00100000): bit_width=6
// v=0x3F(00111111): bit_width=6
// v=0x40(01000000): bit_width=7

#if __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__
  // リトルエンディアン
#elif __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_BIG__
  // ビッグエンディアン
#endif

Runnable runner = new Runnable() {
  @Override
  public void run() {
    System.out.println("Hello, World!");
  }
};

runner.run();

Runnable runner = () -> System.out.println("Hello, World!");
runner.run();

interface FunctionalInterfaceExample {
  void run(String message);
}

FunctionalInterfaceExample example = (message) -> System.out.println(message);
example.run("Hello, Functional Interface!");

interface FunctionalInterfaceExample {
  void run(String message);
  void hoge();
}

FunctionalInterfaceExample example = (message) -> System.out.println(message);
example.run("Hello, Functional Interface!");

// main.java:24: error: incompatible types: FunctionalInterfaceExample is not a functional interface
//     FunctionalInterfaceExample example = (message) -> {
//                                          ^
//     multiple non-overriding abstract methods found in interface FunctionalInterfaceExample
// 1 error
// error: compilation failed

@FunctionalInterface
interface FunctionalInterfaceExample {
  void run(String message);
}

Function<String, Integer> stringLengthFunction = (str) -> str.length() * 10;
int length = stringLengthFunction.apply("Hello");
System.out.println("Length: " + length);    // Outputs: Length: 50

Consumer<String> printer = (message) -> System.out.println(message);
printer.accept("Hello, Consumer!");     // Outputs: Hello, Consumer!

Predicate<String> isHello = (str) -> str != null && str.equals("hello");
System.out.println(isHello.test("hello"));  // Outputs: true
System.out.println(isHello.test(null));     // Outputs: false

Supplier<Double> randomSupplier = () -> Math.random();
System.out.println("Random number: " + randomSupplier.get());

String[] names = {"佐藤", "鈴木", "高橋", "田中", "伊藤", "伊藤"};

// List型に変換
List<String> nameList = Arrays.stream(names).collect(Collectors.toList());
IO.println(nameList);   // [佐藤, 鈴木, 高橋, 田中, 伊藤, 伊藤]

// Set型に変換
Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());
IO.println(nameSet);    // [佐藤, 鈴木, 高橋, 田中, 伊藤]

// 任意のCollection型に変換
Deque<String> nameDeque = Arrays.stream(names).collect(Collectors.toCollection(ArrayDeque::new));
IO.println(nameDeque);  // [佐藤, 鈴木, 高橋, 田中, 伊藤, 伊藤]

Person[] people = {
  new Person("ID1", "佐藤"),
  new Person("ID2", "鈴木"),
  new Person("ID3", "高橋"),
  new Person("ID4", "田中"),
  new Person("ID5", "伊藤")
};

// IDをキー、Personオブジェクトを値とするMapに変換
Map<String, Person> idToPersonMap = Arrays.stream(people)
  .collect(Collectors.toMap(Person::getId, person -> person));
IO.println(idToPersonMap);  // {ID1=Person@1a2b3c4, ID2=Person@5d6e7f8, ID3=Person@9a0b1c2, ID4=Person@3d4e5f6, ID5=Person@7a8b9c0}

// IDをキー、名前を値とするMapに変換
Map<String, String> idToNameMap = Arrays.stream(people)
  .collect(Collectors.toMap(Person::getId, Person::getName));
IO.println(idToNameMap);  // {ID1=佐藤, ID2=鈴木, ID3=高橋, ID4=田中, ID5=伊藤}

Person[] people = {
  new Person("佐藤", 28),
  new Person("鈴木", 34),
  new Person("高橋", 22),
  new Person("田中", 40),
  new Person("伊藤", 30)
};

// 区切り文字なしで連結
String result1 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining());
IO.println(result1);  // 佐藤鈴木高橋田中伊藤

// 区切り文字ありで連結
String result2 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining(", "));
IO.println(result2);  // 佐藤, 鈴木, 高橋, 田中, 伊藤

// 接頭辞?接尾辞ありで連結
String result3 = Arrays.stream(people).map(Person::getName)
  .collect(Collectors.joining(", ", "★開始★, ", ", ★終了★"));
IO.println(result3);  // ★開始★, 佐藤, 鈴木, 高橋, 田中, 伊藤, ★終了★

Person[] people = {
  new Person("佐藤", 28),
  new Person("鈴木", 34),
  new Person("高橋", 22),
  new Person("田中", 40),
  new Person("伊藤", 30)
};

// 平均年齢
double averageAge = Arrays.stream(people)
  .collect(Collectors.averagingInt(Person::getAge));
IO.println(averageAge);  // 30.8

// 最年長
int maxAge = Arrays.stream(people)
  .collect(Collectors.summarizingInt(Person::getAge))
  .getMax();
IO.println(maxAge);      // 40

// 一括集計 (個数、合計、最小、平均、最大)
IntSummaryStatistics ageStats = Arrays.stream(people)
  .collect(Collectors.summarizingInt(Person::getAge));
IO.println(ageStats);    // IntSummaryStatistics{count=5, sum=154, min=22, average=30.800000, max=40

Person[] people = {
  new Person("佐藤", 28, "営業"),
  new Person("鈴木", 34, "開発"),
  new Person("高橋", 22, "営業"),
  new Person("田中", 40, "開発"),
  new Person("伊藤", 30, "総務")
};

// 部署ごとにグルーピング
Map<String, List<Person>> groupedByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(Person::getDepartment));
IO.println(groupedByDepartment);          // {営業=[Person@1a2b3c4, Person@5d6e7f8], 開発=[Person@9a0b1c2, Person@3d4e5f6], 総務=[Person@7a8b9c0]}
IO.println(groupedByDepartment.get("営業").get(0).getName());  // 佐藤

// 部署ごとに年齢の平均を算出
Map<String, Double> averageAgeByDepartment = Arrays.stream(people)  
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.averagingInt(Person::getAge)
  ));
IO.println(averageAgeByDepartment);       // {営業=25.0, 開発=37.0, 総務=30.0}

// 部署ごとに最年長者を取得
Map<String, Optional<Person>> oldestByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.maxBy(Comparator.comparingInt(Person::getAge))
  ));
IO.println(oldestByDepartment.get("開発").get().getName());  // 田中

Person[] people = {
  new Person("佐藤", 28, "営業"),
  new Person("鈴木", 34, "開発"),
  new Person("高橋", 22, "営業"),
  new Person("田中", 40, "開発"),
  new Person("伊藤", 30, "総務")
};

// 部署ごとに名前のリストを取得
Map<String, List<String>> namesByDepartment = Arrays.stream(people)
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.mapping(Person::getName, Collectors.toList())
  ));
IO.println(namesByDepartment);  // {営業=[佐藤, 高橋], 開発=[鈴木, 田中], 総務=[伊藤]}

// 部署ごとに名前をカンマ区切りでグルーピング
Map<String, String> namesJoinedByDepartment = Arrays.stream(people) 
  .collect(Collectors.groupingBy(
    Person::getDepartment,
    Collectors.collectingAndThen(
      Collectors.mapping(Person::getName, Collectors.toList()),
      names -> String.join(", ", names)
    )
  ));
IO.println(namesJoinedByDepartment);  // {営業=佐藤, 高橋, 開発=鈴木, 田中, 総務=伊藤}

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = new ArrayList<>();
for (String name : names) {
  if (name.contains("藤")) {
    filteredNames.add(name);
  }
}
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

// Listの場合
List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
Stream<String> nameStream = names.stream();

// Setの場合
Set<String> nameSet = Set.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
Stream<String> nameStreamFromSet = nameSet.stream();

// Mapの場合
Map<String, Integer> nameAgeMap = Map.ofEntries(
  Map.entry("佐藤", 30),
  Map.entry("鈴木", 25),
  Map.entry("高橋", 28),
  Map.entry("田中", 22),
  Map.entry("伊藤", 35)
);
Stream<Map.Entry<String, Integer>> nameAgeStream = nameAgeMap.entrySet().stream();

// 配列の場合
String[] nameArray = {"佐藤", "鈴木", "高橋", "田中", "伊藤"};
Stream<String> nameStreamFromArray = Arrays.stream(nameArray);

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> uppercasedNames = names.stream()
  .map(name -> name + "さん")
  .collect(Collectors.toList());
IO.println(uppercasedNames);    // [佐藤さん, 鈴木さん, 高橋さん, 田中さん, 伊藤さん]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤", "佐藤", "伊藤");
List<String> distinctNames = names.stream()
  .distinct()
  .collect(Collectors.toList());
IO.println(distinctNames);    // [佐藤, 鈴木, 高橋, 田中, 伊藤]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> sortedNames = names.stream()
  .sorted()
  .collect(Collectors.toList());
IO.println(sortedNames);    // [伊藤, 佐藤, 鈴木, 高橋, 田中]

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
names.stream().forEach(name -> IO.println(name));
// 佐藤
// 鈴木
// 高橋
// 田中
// 伊藤

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
List<String> filteredNames = names.stream()
  .filter(name -> name.contains("藤"))
  .collect(Collectors.toList());
IO.println(filteredNames);    // [佐藤, 伊藤]

List<String> names02 = List.of("佐藤", "鈴木一", "高橋", "田中恵", "伊藤", "山", "小林", "山田太郎");
Map<Integer, List<String>> groupedByLength = names02.stream()
  .collect(Collectors.groupingBy(String::length));
IO.println(groupedByLength);    // {1=[山], 2=[佐藤, 高橋, 伊藤, 小林], 3=[鈴木一, 田中恵], 4=[山田太郎]}

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");
long count = names.stream()
  .filter(name -> name.contains("藤"))
  .count();
IO.println(count);    // 2

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream()
  .reduce(0, Integer::sum);
IO.println(sum);    // 15

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum2 = numbers.stream()
  .mapToInt(Integer::intValue)
  .sum();
IO.println(sum2);    // 15

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");

// anyMatch
boolean hasSuzuki = names.stream()
  .anyMatch(name -> name.equals("鈴木"));
IO.println(hasSuzuki);    // true

// allMatch
boolean allHaveTo = names.stream()
  .allMatch(name -> name.contains("田"));
IO.println(allHaveTo);    // false

// noneMatch
boolean noneHaveYamamoto = names.stream()
  .noneMatch(name -> name.equals("山本"));
IO.println(noneHaveYamamoto);    // true

List<String> names = List.of("佐藤", "鈴木", "高橋", "田中", "伊藤");

names.parallelStream()
.filter(name -> {
  IO.println("フィルタ中: " + name + " - " + Thread.currentThread().getName());
  return name.contains("藤");
})
.map(name -> {
  IO.println("変換中: " + name + " - " + Thread.currentThread().getName());
  return "こんにちは、" + name + "さん";
})
.forEach(name -> IO.println(name));

フィルタ中: 伊藤 - ForkJoinPool.commonPool-worker-3
フィルタ中: 佐藤 - ForkJoinPool.commonPool-worker-2
フィルタ中: 田中 - ForkJoinPool.commonPool-worker-4
変換中: 伊藤 - ForkJoinPool.commonPool-worker-3
変換中: 佐藤 - ForkJoinPool.commonPool-worker-2
フィルタ中: 高橋 - main
フィルタ中: 鈴木 - ForkJoinPool.commonPool-worker-1
こんにちは、佐藤さん
こんにちは、伊藤さん

// Expected output:
// Value: 1, Index: 0, Array: [1,2,3,4,5]
// Value: 2, Index: 1, Array: [1,2,3,4,5]
// Value: 3, Index: 2, Array: [1,2,3,4,5]
// Value: 4, Index: 3, Array: [1,2,3,4,5]
// Value: 5, Index: 4, Array: [1,2,3,4,5]
function sample_forEach() {
  const array = [1, 2, 3, 4, 5];
  array.forEach((value, index, arr) => {
    console.log(`Value: ${value}, Index: ${index}, Array: [${arr}]`);
  });
}

// Expected output:
// find(): 3
// findIndex(): 2
// findLast(): 5
// findLastIndex(): 4
function sample_find() {
  const array = [1, 2, 3, 4, 5];

  // find(): 最初に条件を満たす値を返します。
  const found = array.find((value) => value > 2);
  console.log(`find(): ${found}`); // 3

  // findIndex(): 最初に条件を満たす値のインデックスを返します。
  const foundIndex = array.findIndex((value) => value > 2);
  console.log(`findIndex(): ${foundIndex}`); // 2

  // findLast(): 最後に条件を満たす値を返します。
  const foundLast = array.findLast((value) => value > 2);
  console.log(`findLast(): ${foundLast}`); // 5

  // findLastIndex(): 最後に条件を満たす値のインデックスを返します。
  const foundLastIndex = array.findLastIndex((value) => value > 2);
  console.log(`findLastIndex(): ${foundLastIndex}`); // 4
}

// Expected output:
// array: [1,2,3,4,5]
// filtered: [2,4]
function sample_filter() {
  const array = [1, 2, 3, 4, 5];
  const filtered = array.filter((value) => value % 2 === 0);
  console.log(`array: [${array}]`); // [1,2,3,4,5]
  console.log(`filtered: [${filtered}]`); // [2,4]
}

function sample_filter_NG() {
  const array = [1, 2, 3, 4, 5]; // 仮にこの配列が非常に大きい場合

  // condA: 2以上の値、condB: 偶数
  const condA = (value: number) => value >= 4;
  const condB = (value: number) => value % 2 === 0;

  // 非効率的な方法: 2回filterを呼び出す
  const result1 = array.filter(condA).filter(condB);

  // 効率的な方法: 1回のfilterで両方の条件をチェック
  const result2 = array.filter(value => condA(value) && condB(value));
}

// Expected output:
// array: [1,2,3]
// mapped: [["No.1","Value:1"],["No.2","Value:2"],["No.3","Value:3"]]
// flatMapped: ["No.1","Value:1","No.2","Value:2","No.3","Value:3"]
function sample_map() {
  const array = [1, 2, 3];
  console.log(`array: [${array}]`); // [1,2,3]
  
  const map = (value: number) => [`No.${value}`, `Value:${value}`]

  // map(): 各要素に対してマッピングを行います。
  const mapped = array.map(map);
  console.log(`mapped: ${JSON.stringify(mapped)}`); // [["No.1","Value:1"],["No.2","Value:2"],["No.3","Value:3"]]

  // flatMap(): 各要素に対してマッピングし、結果の配列をフラット化します。
  const flatMapped = array.flatMap(map);
  console.log(`flatMapped: ${JSON.stringify(flatMapped)}`); // ["No.1","Value:1","No.2","Value:2","No.3","Value:3"]
}

// Expected output:
// every(): false
// some(): true
function sample_every_some() {
  const array = [1, 2, 3, 4, 5];

  // every(): 全ての要素が条件を満たす場合にtrueを返します。
  const isAllEven = array.every(value => value % 2 === 0);
  console.log(`every(): ${isAllEven}`); // false

  // some(): 少なくとも1つの要素が条件を満たす場合にtrueを返します。
  const hasEven = array.some(value => value % 2 === 0);
  console.log(`some(): ${hasEven}`); // true
}

// Expected output:
// reduce(): -1-2-3-4-5
// reduceRight(): -5-4-3-2-1
function sample_reduce() {
  const array = [1, 2, 3, 4, 5];

  // reduce(): 配列の左から右へ集約処理を行います。
  const sum = array.reduce((acc, value) => acc + '-' + value, '');
  console.log(`reduce(): ${sum}`); // -1-2-3-4-5

  // reduceRight(): 配列の右から左へ集約処理を行います。
  const concatRight = array.reduceRight((acc, value) => acc + '-' + value, '');
  console.log(`reduceRight(): ${concatRight}`); // -5-4-3-2-1
}

function sample01() {
  const array = [1, 2, 3, 4, 5];  // 仮にこの配列が非常に大きい場合
  // filterとmapを連続で呼び出す方法 → 2回ループしているため非効率
  const result = array.filter((value) => value % 2 === 0).map((value) => value * 2);
  console.log(`result: [${result}]`); // [4,8]
}

function sample02() {
  const array = [1, 2, 3, 4, 5];  // 仮にこの配列が非常に大きい場合

  // 単一のループでfilterとmapの両方を実行する方法 → 1回のループで済むため効率的
  let result = [];
  for (const value of array) {
    if (value % 2 === 0) {
      result.push(value * 2);
    }
  }

  console.log(`result: [${result}]`); // [4,8]
}

  public static int linearSearch(int[] array, int target) {
    for (int i = 0; i < array.length; i++) {
      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

// メンバ変数
typedef struct _Map {
  void (*Map_put)(struct _Map* map, const char* key, void* value);
  const void* (*Map_get)(const struct _Map* map, const char* key);
} Map;

// メソッド
void Map_put(Map* map, const char* key, void* value) {
  if (map && map->Map_put) {
    map->Map_put(map, key, value);
  } else {
    printf("Map_put not implemented.\n");
  }
}

// Map_getも同じように実装する

typedef struct {
  char* key;      // 文字列キー
  void* value;    // 値
} HashMapEntry;

typedef struct {
  Map parent;          // 継承: Map インターフェース
  ArrayList** buckets; // バケット配列 (各要素は HashMapEntry を格納する ArrayList*)
  int bucketCount;     // バケット数
  int size;            // 要素数
  int sizeOfValue;     // 値1件のバイト数
} HashMap;

// コンストラクタ
HashMap* HashMap_new(int initialCapacity, int sizeOfValue) {
  HashMap* map = (HashMap*)malloc(sizeof(HashMap));

  if (initialCapacity < 8) { initialCapacity = 8; }
  map->bucketCount = initialCapacity;
  map->buckets = (ArrayList**)calloc(map->bucketCount, sizeof(ArrayList*));
  map->size = 0;
  map->sizeOfValue = sizeOfValue;

  // オーバーライド
  map->parent.Map_put = HashMap_put;
  map->parent.Map_get = HashMap_get;
  return map;
}

// デストラクタ
void HashMap_delete(HashMap* map) {
  if (!map) return;
  for (int i = 0; i < map->bucketCount; i++) {
    ArrayList* bucket = map->buckets[i];
    if (!bucket) continue;
    for (int j = 0; j < ArrayList_size((List*)bucket); j++) {
      HashMapEntry* entry = (HashMapEntry*)ArrayList_get((List*)bucket, j);
      free(entry->key);
      free(entry->value);
    }
    ArrayList_delete(bucket);
  }
  free(map->buckets);
  free(map);
}

// 負荷係数が 0.75 を超えたらリサイズ
#define HASHMAP_LOAD_FACTOR 0.75

// 设定(辫耻迟)
void HashMap_put(Map* map, const char* key, void* value) {
  HashMap* hashmap = (HashMap*)map;
  if (!hashmap || !key) return;

  // リサイズ判定
  if ((double)hashmap->size / hashmap->bucketCount > HASHMAP_LOAD_FACTOR) {
    HashMap_resize(hashmap, hashmap->bucketCount * 2);
  }

  // ハッシュ値を計算し、設定先のIndexを求める
  // ハッシュ値はDJB2にて作成する。詳細は割愛。
  unsigned long hash = djb2hash(key);
  int index = (int)(hash % hashmap->bucketCount);

  // バケットが無い場合は作成する
  ArrayList* bucket = hashmap->buckets[index];
  if (!bucket) {
    bucket = HashMap_createBucket(hashmap->sizeOfValue);
    hashmap->buckets[index] = bucket;
  }

  // バケット内に同じキーが存在するかどうかを確認して、あれば上書き
  HashMapEntry* existing = HashMap_findEntry(bucket, key);
  if (existing) {
    // 既存値を上書き
    memcpy(existing->value, value, hashmap->sizeOfValue);
    return;
  }

  // 新規エントリ作成
  HashMapEntry entry;
  entry.key = (char*)malloc(strlen(key) + 1);
  strcpy(entry.key, key);
  entry.value = malloc(hashmap->sizeOfValue);
  memcpy(entry.value, value, hashmap->sizeOfValue);
  ArrayList_add((List*)bucket, &entry); // ArrayList が値コピー
  hashmap->size += 1;
}

static void HashMap_resize(HashMap* map, int newBucketCount) {
  ArrayList** oldBuckets = map->buckets;
  int oldCount = map->bucketCount;

  // 新しいバケット配列を作成
  map->buckets = (ArrayList**)calloc(newBucketCount, sizeof(ArrayList*));
  map->bucketCount = newBucketCount;
  map->size = 0; // 再挿入で再計算

  for (int i = 0; i < oldCount; i++) {
    ArrayList* bucket = oldBuckets[i];
    if (!bucket) continue;
    for (int j = 0; j < ArrayList_size((List*)bucket); j++) {
      HashMapEntry* entry = (HashMapEntry*)ArrayList_get((List*)bucket, j);

      // ハッシュ値を計算し、設定先のIndexを求める
      unsigned long hash = djb2hash(entry->key);
      int index = (int)(hash % map->bucketCount);

      // バケットが無い場合は作成する
      ArrayList* newBucket = map->buckets[index];
      if (!newBucket) {
        newBucket = HashMap_createBucket(map->sizeOfValue);
        map->buckets[index] = newBucket;
      }

      // 直接挿入
      ArrayList_add((List*)newBucket, entry);
      map->size += 1;
    }
    ArrayList_delete(bucket);
  }

  // 古いバケット配列を解放
  free(oldBuckets);
}

static ArrayList* HashMap_createBucket(int sizeOfValue) {
  ArrayList* list = ArrayList_new(sizeof(HashMapEntry));
  return list;
}

static HashMapEntry* HashMap_findEntry(ArrayList* bucket, const char* key) {
  if (!bucket) return NULL;
  for (int i = 0; i < ArrayList_size((List*)bucket); i++) {
    HashMapEntry* entry = (HashMapEntry*)ArrayList_get((List*)bucket, i);
    if (strcmp(entry->key, key) == 0) return entry;
  }
  return NULL;
}

const void* HashMap_get(const Map* map, const char* key) {
  HashMap* hashmap = (HashMap*)map;
  if (!hashmap || !key) return NULL;

  // ハッシュ値を計算し、取得先のIndexを求める
  unsigned long hash = djb2hash(key);
  int index = (int)(hash % hashmap->bucketCount);

  // バケットを取得
  ArrayList* bucket = hashmap->buckets[index];
  if (!bucket) return NULL;

  // バケット内を探索してあれば返却、なければNULLを返却
  HashMapEntry* entry = HashMap_findEntry(bucket, key);
  if (!entry) return NULL;
  return entry->value;
}

void process(Map* map) {

  // 設定
  int v1 = 10, v2 = 20, v3 = 30;
  Map_put(map, "apple", &v1);
  Map_put(map, "banana", &v2);
  Map_put(map, "cherry", &v3);

  // 上書き
  int v2b = 200;
  Map_put(map, "banana", &v2b);

  // 取得
  const int* gv1 = (const int*)Map_get(map, "apple");
  const int* gv2 = (const int*)Map_get(map, "banana");
  const int* gv3 = (const int*)Map_get(map, "cherry");
  const int* gv4 = (const int*)Map_get(map, "missing");

  // 結果表示
  printf("apple=%d banana=%d cherry=%d missing=%s\n", 
      gv1?*gv1:-1, gv2?*gv2:-1, gv3?*gv3:-1, gv4 ? "FOUND" : "NULL");
}


int main() {

  HashMap* map = HashMap_new(8, sizeof(int));
  process((Map*)map);
  HashMap_delete(map);

  return 0;
}

$ gcc *.c && ./a.out
apple=10 banana=200 cherry=30 missing=NULL

renovate:
  stage: renovate
  image:
    name: renovate/renovate:latest
    entrypoint: [""]
  script:
    - renovate --platform gitlab --token $GITLAB_TOKEN --endpoint $CI_SERVER_URL/api/v4 $CI_PROJECT_PATH
  rules:
    - if: $RENOVATE && $CI_PIPELINE_SOURCE == "schedule"

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
}

class Example {
public:
  Example() {
    printf("This is the constructor.\n");
  }
  ~Example() {
    printf("This is the destructor.\n");
  }
};

// メイン処理
int main() {
  {
    Example example;
    printf("before\n");
  }
  printf("after\n");
  return 0;
}

This is the constructor.
before
This is the destructor.
after

template <class T>
class MemPointer {
public:
  T* ptr;

  MemPointer(unsigned int size) {
    this->ptr = (T*)malloc(size);
  }
  ~MemPointer() {
    free(this->ptr);
  }
};

typedef struct _Person {
  char name[256];
} Person;

// メイン処理
int main() {

  {
    MemPointer<Person> person(sizeof(Person));
    memcpy(person.ptr->name, "n-ozawan", sizeof(Person::name));
    printf("My name is %s\n", person.ptr->name);
  } // ここでメモリが解放される

  return 0;
}

typedef struct _Person {
  char name[256];
} Person;

int main(){

  {
    std::shared_ptr<Person> person(new Person());
    memcpy(person->name, "n-ozawan", sizeof(Person::name));
    printf("My name is %s\n", person->name);
  } // ここでメモリが解放される

   return 0;
}

class LogTrace {
private:
  const char* message;

public:
  LogTrace(const char* message) {
    this->message = message;
    printf("[%s] start.\n", this->message);
  }
  ~LogTrace() {
    printf("[%s] end.\n", this->message);
  }
};

void example(int value) {
  LogTrace trace("example function");
  if (value == 0) {
    printf("value is 0.\n");
    return ;
  }
  return ;
} 

// メイン処理
int main() {
  example(1);
  example(0);
  return 0;
}

[example function] start.
[example function] end.
[example function] start.
value is 0.
[example function] end.

<html>
<head></head>
<body>
  <div style="width: 80%">
    <canvas id="myChart"></canvas>
  </div>

  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

  <script>
  const ctx = document.getElementById('myChart');

  new Chart(ctx, {
    type: 'bar',
    data: {
      labels: ['Red', 'Blue', 'Yellow', 'Green', 'Purple', 'Orange'],
      datasets: [{
        label: '# of Votes',
        data: [12, 19, 3, 5, 2, 3],
        borderWidth: 1
      }]
    },
    options: {
    scales: {
        y: {
          beginAtZero: true
        }
      }
    }
  });
  </script>
</body>
</html>

 <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

  <div style="width: 80%">
    <canvas id="myChart"></canvas>
  </div>

  <!-- 省略 -->

  const ctx = document.getElementById('myChart');

  new Chart(ctx, {
    type: 'line',
    data: {
      labels: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
      datasets: [
        {
          label: 'Dataset 1',
          data: [89, 55, 40, 42, 46, 6, 27],
        },
        {
          label: 'Dataset 2',
          data: [0, 47, 73, 37, 85, 76],
        },
        {
          label: 'Dataset 3',
          data: [56, 98, 23, 27, 32, 53, 67, 34],
        }
      ]
    },
    options: {},
  });

<html>
<head></head>
<body>
  <div style="width: 80%">
    <canvas id="myChart"></canvas>
  </div>

  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

  <script>
  const ctx = document.getElementById('myChart');

  new Chart(ctx, {
    type: 'line',
    data: {
      labels: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
      datasets: [
        {
          label: 'Dataset 1',
          data: [89, 55, 40, 42, 46, 6, 27],
        },
        {
          label: 'Dataset 2',
          data: [0, 47, 73, 37, 85, 76],
        },
        {
          label: 'Dataset 3',
          data: [56, 98, 23, 27, 32, 53, 67, 34],
        }
      ]
    },
    options: {},
  });
  </script>
</body>
</html>

<chart-provider data-chartdata={JSON.stringify(progressChartData)}>
  <h3>グラフ</h3>
  <canvas/>
</chart-provider>

<script>
  import { Chart, registerables, type ChartData } from "chart.js"
  Chart.register(...registerables);

  class ChartProvider extends HTMLElement {
    constructor() {
      super();

      const ctx = this.getElementsByTagName("canvas");
      const chartData: ChartData = JSON.parse(this.dataset.chartdata ?? "{}");

      new Chart(ctx, {
        type: 'line',
        data: Object.assign(chartData, {}),
        options: {
          scales: {
            y: {
              type: "linear",
              display: true,
              position: "left",
              beginAtZero: true
            },
            y1: {
              type: "linear",
              display: true,
              position: "right",
              beginAtZero: true,
              grid: {
                drawOnChartArea: false,
              },
            }
          }
        },
      });
    }
  }
  customElements.define("chart-provider", ChartProvider)
</script>

npm i xlsx

import * as xlsx from "xlsx"
import { WorkBook, WorkSheet } from "xlsx"

const workbook: WorkBook = xlsx.readFile("example.xlsx");
const sheet: WorkSheet = workbook.Sheets["Example01"];
const rows: any[] = xlsx.utils.sheet_to_json(sheet);
console.log(rows);

[
  {
    'No.': 1,
    'テスト内容': '自分の足で立って歩けること',
    '実施日': 45597,
    '実施者': 'n-ozawan',
    '実施結果': 'OK'
  },
  {
    'No.': 2,
    'テスト内容': '自分の足で立って走れること',
    '実施日': 45598,
    '実施者': 'n-ozawan',
    '実施結果': 'NG',
    '備考': '歳には勝てない。'
  }
]

console.log(rows[1]["テスト内容"]);   // 自分の足で立って走れること

const workbook: WorkBook = xlsx.readFile("example.xlsx", { cellText: false, cellDates: true });
const sheet: WorkSheet = workbook.Sheets["Example01"];
const rows: any[] = xlsx.utils.sheet_to_json(sheet, { raw: false, dateNF: 'yyyy"-"mm"-"dd' });
console.log(rows);

[
  {
    'No.': '1',
    'テスト内容': '自分の足で立って歩けること',
    '実施日': '2024-11-01',
    '実施者': 'n-ozawan',
    '実施結果': 'OK'
  },
  {
    'No.': '2',
    'テスト内容': '自分の足で立って走れること',
    '実施日': '2024-11-02',
    '実施者': 'n-ozawan',
    '実施結果': 'NG',
    '備考': '歳には勝てない。'
  }
]

[
  { '総数': '2', 'OK件数': '1' },
  {
    __EMPTY: 'No.',
    __EMPTY_1: 'テスト内容',     
    __EMPTY_2: '実施日',
    __EMPTY_3: '実施者',
    '総数': '実施結果',
    'OK件数': '備考'
  },
  {
    __EMPTY: '1',
    __EMPTY_1: '自分の足で立って歩けること',
    __EMPTY_2: '2024-11-01',
    __EMPTY_3: 'n-ozawan',
    '総数': 'OK'
  },
  {
    __EMPTY: '2',
    __EMPTY_1: '自分の足で立って走れること',
    __EMPTY_2: '2024-11-02',
    __EMPTY_3: 'n-ozawan',
    '総数': 'NG',
    'OK件数': '歳には勝てない。'
  }
]

const rows: any[] = xlsx.utils.sheet_to_json(sheet, {
  header: "A",
  raw: false,
  dateNF: 'yyyy"-"mm"-"dd'
});

[
  { E: '総数', F: 'OK件数' },
  { E: '2', F: '1' },
  { A: 'No.', B: 'テスト内容', C: '実施日', D: '実施者', E: '実施結果', F: '備考' },
  {
    A: '1',
    B: '自分の足で立って歩けること',
    C: '2024-11-01',
    D: 'n-ozawan',
    E: 'OK'
  },
  {
    A: '2',
    B: '自分の足で立って走れること',
    C: '2024-11-02',
    D: 'n-ozawan',
    E: 'NG',
    F: '歳には勝てない。'
  }
]

const rows: any[] = xlsx.utils.sheet_to_json(sheet, {
  header: [ "No.", "テスト内容", "実施日", "実施者", "実施結果", "備考" ],
  raw: false,
  dateNF: 'yyyy"-"mm"-"dd'
});

[
  { '実施結果': '総数', '備考': 'OK件数' },
  { '実施結果': '2', '備考': '1' },
  {
    'No.': 'No.',
    'テスト内容': 'テスト内容',
    '実施日': '実施日',
    '実施者': '実施者',
    '実施結果': '実施結果',
    '備考': '備考'
  },
  {
    'No.': '1',
    'テスト内容': '自分の足で立って歩けること',
    '実施日': '2024-11-01',
    '実施者': 'n-ozawan',
    '実施結果': 'OK'
  },
  {
    'No.': '2',
    'テスト内容': '自分の足で立って走れること',
    '実施日': '2024-11-02',
    '実施者': 'n-ozawan',
    '実施結果': 'NG',
    '備考': '歳には勝てない。'
  }
]

// メンバ変数
typedef struct _List {
  void (*List_add)(struct _List* list, void* element);
  void (*List_insert)(struct _List* list, int index, void* element);
  const void* (*List_get)(const struct _List* list, int index);
  int (*List_size)(const struct _List* list);
} List;

// メソッド
void List_add(List* list, void* element) {
  if (list->List_add) {
    list->List_add(list, element);
  } else {
    printf("not implemented.\n");
  }
}

// 以下略。
// List_insert(...), List_get(...), List_size(...) も、List_add(...)と同じように実装する。

// メンバ変数
typedef struct {
  List parent;        // 継承
  void* array;        // 配列の実体
  int sizeOfElement;  // 要素1個分のサイズ
  int length;         // 配列に格納した要素数
  int maxLength;      // メモリ確保した配列の数
} ArrayList;

// コンストラクタ
ArrayList* ArrayList_new(int sizeOfElement) {
  ArrayList* list = (ArrayList*)malloc(sizeof(ArrayList));

  // 初期配列の作成
  list->length = 0;
  list->maxLength = 10;
  list->sizeOfElement = sizeOfElement;
  list->array = (void*)malloc(sizeOfElement * list->maxLength);

  // オーバーライド
  list->parent.List_add = ArrayList_add;
  list->parent.List_insert = ArrayList_insert;
  list->parent.List_get = ArrayList_get;
  list->parent.List_size = ArrayList_size;
  return list;
}

// デストラクタ
void ArrayList_delete(ArrayList* arraylist) {
  if (arraylist->array) free(arraylist->array);
  free(arraylist);
}

const void* ArrayList_get(const List* list, int index) {
  ArrayList* arraylist = (ArrayList*)list;
  return arraylist->array + (index * arraylist->sizeOfElement);
}

int ArrayList_ensureCapacity(ArrayList* arraylist, int minCapacity) {
  void* newarray = realloc(arraylist->array, arraylist->sizeOfElement * minCapacity);
  if (newarray == 0) {
    printf("out of memory.");
    return -1;
  }
  arraylist->maxLength = minCapacity;
  arraylist->array = newarray;
  return 0;
}

void ArrayList_add(List* list, void* element) {
  ArrayList* arraylist = (ArrayList*)list;
  if (arraylist->length == arraylist->maxLength) {
    int result = ArrayList_ensureCapacity(arraylist, arraylist->maxLength * 1.4);
    if (result != 0) return;
  }
  memcpy(arraylist->array + (arraylist->length * arraylist->sizeOfElement), element, arraylist->sizeOfElement);
  arraylist->length += 1;
}

void ArrayList_insert(List* list, int index, void* element) {
  ArrayList* arraylist = (ArrayList*)list;
  if (arraylist->length == arraylist->maxLength) {
    int result = ArrayList_ensureCapacity(arraylist, arraylist->maxLength * 1.4);
    if (result != 0) return;
  }
  memcpy(arraylist->array + ((index + 1) * arraylist->sizeOfElement), 
         arraylist->array + (index * arraylist->sizeOfElement),
         (arraylist->length - index) * arraylist->sizeOfElement);
  memcpy(arraylist->array + (index * arraylist->sizeOfElement), element, arraylist->sizeOfElement);
  arraylist->length += 1;
}

int ArrayList_size(const List* list) {
  ArrayList* arraylist = (ArrayList*)list;
  return arraylist->length;
}

void process(List* list) {
  // 配列の末尾に追加
  for (int i = 0; i < 20; i++) {
    List_add(list, &i);
  }

  // 配列の途中に挿入
  int value = 99;
  List_insert(list, 10, &value);

  // 結果を出力
  for (int i = 0; i < List_size(list); i++) {
    int* value = (int*)List_get(list, i);
    printf("%d ", *value);
  }
  printf("\n");
}

int main() {
  ArrayList* arraylist = ArrayList_new(sizeof(int));

  process((List*)arraylist);
  // Output: 0 1 2 3 4 5 6 7 8 9 99 10 11 12 13 14 15 16 17 18 19 

  ArrayList_delete(arraylist);
  return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// メンバ変数
typedef struct {
  char label[256];
} Button;

// 初期化
Button* initButton(Button* button, const char* label) {
  memcpy(button->label, label, sizeof(button->label));
  return button;
}

// コンストラクタ
Button* newButton(const char* label) {
  Button* button = (Button*)malloc(sizeof(Button));
  return initButton(button, label);
}

// メソッド
void pushButton(Button* button) {
  printf("push \"%s\" button!\n", button->label);
}

// メイン処理
int main() {
  Button* b = newButton("hoge");

  pushButton(b);

  free(b);
  return 0;
}

// メンバ変数
typedef struct {
  Button parent;    // Buttonクラスを継承
  char method[8];
  char action[256];
} SubmitButton;

// コンストラクタ
SubmitButton* newSubmitButton(const char* label, const char* method, const char* action) {
  SubmitButton* button = (SubmitButton*)malloc(sizeof(SubmitButton));
  initButton(&button->parent, label);
  memcpy(button->method, method, sizeof(button->method));
  memcpy(button->action, action, sizeof(button->action));
  return button;
}

// メイン処理
int main() {
  Button* b = (Button*)newSubmitButton("hoge", "GET", "/example");

  pushButton(b);

  free(b);
  return 0;
}

// ============================================================================
// Button クラス
// ============================================================================

// メンバ変数
typedef struct _Button {
  char label[256];
  void (*pushButton)(struct _Button* button);     // 関数ポインタ
} Button;

// メソッド
void pushButton(Button* button) {
  if (button->pushButton != 0) {
    button->pushButton(button);
  } else {
    printf("push \"%s\" button!\n", button->label);
  }
}

// 初期化
Button* initButton(Button* button, const char* label) {
  memset(button, 0, sizeof(Button));
  memcpy(button->label, label, sizeof(button->label));
  return button;
}

// コンストラクタ
Button* newButton(const char* label) {
  Button* button = (Button*)malloc(sizeof(Button));
  return initButton(button, label);
}

// ============================================================================
// SubmitButton クラス
// ============================================================================

// メンバ変数
typedef struct {
  Button parent;    // 継承
  char method[8];
  char action[256];
} SubmitButton;

// メソッド
void pushSubmitButton(Button* button) {
  SubmitButton* submitButton = (SubmitButton*)button;
  printf("Request %s %s\n", submitButton->method, submitButton->action);
}

// コンストラクタ
SubmitButton* newSubmitButton(const char* label, const char* method, const char* action) {
  SubmitButton* button = (SubmitButton*)malloc(sizeof(SubmitButton));
  initButton(&button->parent, label);
  memcpy(button->method, method, sizeof(button->method));
  memcpy(button->action, action, sizeof(button->action));

  button->parent.pushButton = pushSubmitButton;     // オーバーライド
  return button;
}

// ============================================================================
// メイン処理
// ============================================================================
int main() {
  Button* b1 = (Button*)newButton("hoge");
  Button* b2 = (Button*)newSubmitButton("hoge", "GET", "/example");

  pushButton(b1);    // Output: push "hoge" button! 
  pushButton(b2);    // Output: Request GET /example

  free(b1);
  free(b2);
  return 0;
}

#include <stdio.h>
#include <string.h>

class Button {
private:
  // メンバ変数
  char label[256];

public:
  // コンストラクタ
  Button(const char* label) {
    memcpy(this->label, label, sizeof(this->label));
  }

  // メソッド
  void push() {
    printf("push `%s` button!\n", this->label);
  }
};

// メイン処理
int main() {
  Button* b = new Button("hoge");

  b->push();

  delete b;
  return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// メンバ変数
typedef struct {
  char label[256];
} Button;

// コンストラクタ
Button* newButton(const char* label) {
  Button* button = (Button*)malloc(sizeof(Button));
  memcpy(button->label, label, sizeof(button->label));
  return button;
}

// メソッド
void pushButton(Button* button) {
  printf("push `%s` button!\n", button->label);
}

// メイン処理
int main() {
  Button* b = newButton("hoge");

  pushButton(b);

  free(b);
  return 0;
}

// メンバ変数
typedef struct {
  char label[256];
} Button;

// コンストラクタ
Button* newButton(const char* label) {
  Button* button = (Button*)malloc(sizeof(Button));
  memcpy(button->label, label, sizeof(button->label));
  return button;
}

// メソッド
void pushButton(Button* button) {
  printf("push `%s` button!\n", button->label);
}

// メイン処理 (C)
int main() {
  Button* b = newButton("hoge");

  pushButton(b);

  free(b);
  return 0;
}

// メイン処理 (C++)
int main() {
  Button* b = new Button("hoge");

  b->push();

  delete b;
  return 0;
}