데브웁스

Claude Code를 활용한 고품질 애플리케이션 개발 가이드

더해리 — Tue, 24 Feb 2026 00:20:00 +0900

들어가며

Claude Code는 터미널에서 동작하는 에이전틱 코딩 도구로, 코드베이스를 이해하고 자연어 명령을 통해 파일 편집, 명령 실행, Git 워크플로우까지 수행합니다. 이 가이드는 Claude Code를 활용하여 프로덕션 수준의 고품질 애플리케이션을 체계적으로 개발하기 위한 절차와 베스트 프랙티스를 정리합니다.

Phase 1: 프로젝트 인프라 구축

고품질 결과물의 80%는 Claude Code에게 제공하는 컨텍스트 품질에 의해 결정됩니다. 코드 한 줄 작성하기 전에 프로젝트 인프라를 먼저 세팅하세요.

1.1 CLAUDE.md 설정 — 가장 중요한 단일 작업

CLAUDE.md는 Claude Code가 세션 시작 시 자동으로 읽는 프로젝트 메모리 파일입니다. 프로젝트의 컨벤션, 아키텍처, 기술 스택을 명시해두면 Claude가 일관된 코드를 생성합니다.

markdown

# CLAUDE.md

## 프로젝트 개요
- 프로젝트명: my-service
- 설명: 주문 관리 마이크로서비스

## 기술 스택
- Java 21 + Kotlin
- Spring Boot 3.4 (Spring MVC, Spring Data JPA)
- Gradle (Kotlin DSL)
- PostgreSQL, Redis
- RestClient (WebClient 대신 사용)

## 아키텍처 규칙
- Layered Architecture: Controller → Service → Repository
- DTO는 record(Java) 또는 data class(Kotlin) 사용
- Entity와 DTO를 반드시 분리
- 예외 처리는 @RestControllerAdvice 활용

## 코딩 컨벤션
- 패키지 구조: com.example.{도메인}.{layer}
- REST API는 /api/v1 prefix 사용
- 테스트는 반드시 작성 (JUnit 5 + MockK)
- 커밋 메시지: Conventional Commits 형식

## 빌드 & 실행
- 빌드: ./gradlew build
- 테스트: ./gradlew test
- 린트: ./gradlew ktlintCheck
- 실행: ./gradlew bootRun

## 절대 하지 말 것
- WebClient나 RestTemplate 사용 금지 (RestClient만 사용)
- var 남용 금지, 타입을 명시적으로 선언
- 테스트 없이 PR 생성 금지

CLAUDE.md 스코프 활용:

파일 위치적용 범위용도

~/.claude/CLAUDE.md	모든 프로젝트	개인 글로벌 설정
프로젝트루트/CLAUDE.md	해당 프로젝트 전체	팀 공유 컨벤션 (Git 커밋)
프로젝트루트/.claude/CLAUDE.md	해당 프로젝트 (로컬)	개인 로컬 설정 (.gitignore)

1.2 Rules 설정 — 주제별 모듈 지침

.claude/rules/ 디렉토리에 주제별 규칙 파일을 두면, Claude가 관련 작업 시 자동으로 참조합니다. frontmatter로 경로 스코핑도 가능합니다.

markdown

<!-- .claude/rules/api-design.md -->
---
globs: ["**/controller/**", "**/api/**"]
---

# API 설계 규칙
- ResponseEntity로 감싸서 반환
- 페이지네이션은 Spring Data의 Pageable 사용
- 400/404/500 에러 응답 형식 통일

1.3 Skills 설정 — 재사용 가능한 워크플로우

.claude/skills/ 디렉토리에 반복되는 작업 패턴을 정의하면 /skill-name으로 호출할 수 있습니다.

markdown

<!-- .claude/skills/new-api.md -->
# 새 API 엔드포인트 생성

## 절차
1. Controller 클래스 생성 (또는 기존에 추가)
2. Request/Response DTO 정의
3. Service 인터페이스 및 구현체 작성
4. Repository 생성 (필요 시)
5. 통합 테스트 작성
6. API 문서 업데이트

## 참고 패턴
- 기존 예시: src/main/kotlin/com/example/order/controller/OrderController.kt

1.4 Hooks 설정 — 자동 품질 게이트

Hooks는 Claude의 에이전틱 루프 바깥에서 결정론적으로 실행되는 스크립트입니다. 코드 변경 후 자동으로 린트/빌드를 실행하여 품질을 강제할 수 있습니다.

json

// .claude/settings.json
{
  "hooks": {
    "stop": [
      {
        "command": "./gradlew ktlintCheck --quiet",
        "description": "코드 스타일 자동 검증"
      }
    ]
  }
}

Phase 2: 계획 수립 (Plan Before Code)

리서치/계획과 구현을 반드시 분리하세요. Claude가 바로 코딩에 뛰어들게 하면, 잘못된 문제를 풀거나 아키텍처가 꼬이는 경우가 빈번합니다.

2.1 Plan Mode 활용

Shift+Tab 두 번으로 Plan Mode를 활성화합니다. 이 모드에서 Claude는 파일을 읽고 분석할 수 있지만, 어떤 파일도 수정하지 않습니다. 아키텍트 모드라고 생각하면 됩니다.

# Plan Mode에서의 프롬프트 예시
주문 취소 API를 구현해야 합니다.

요구사항:
- PUT /api/v1/orders/{id}/cancel
- 주문 상태가 PENDING일 때만 취소 가능
- 취소 시 재고 복원 필요
- 취소 사유(reason)를 기록

먼저 기존 OrderController와 OrderService를 분석하고,
구현 계획을 세워주세요. 아직 코드를 작성하지 마세요.

2.2 구조화된 프롬프트 작성 (CIF 원칙)

효과적인 프롬프트는 Context(맥락), Intent(의도), **Format(형식)**을 포함합니다.

# ❌ 모호한 프롬프트
폼 추가해줘

# ✅ 구조화된 프롬프트
[Context] OrderController.kt에 주문 수정 API가 필요합니다.
[Intent] 기존 createOrder 패턴을 따라서 updateOrder 엔드포인트를 구현해주세요.
[Format]
- PUT /api/v1/orders/{id}
- UpdateOrderRequest DTO 생성 (수량, 배송주소 변경 가능)
- 서비스 레이어에서 변경 감지 및 이벤트 발행
- 통합 테스트 포함
- 기존 OrderControllerTest.kt 패턴 참고

2.3 검증 기준을 먼저 제시

Claude에게 스스로 검증할 수 있는 수단을 제공하면 품질이 극적으로 향상됩니다. 테스트, 빌드 명령, 린트 등이 여기에 해당합니다.

구현 후 다음을 확인해주세요:
1. ./gradlew test 전체 통과
2. ./gradlew ktlintCheck 통과
3. 기존 테스트가 깨지지 않는지 확인

Phase 3: 구현

3.1 작업 단위 분할

복잡한 기능은 한 번에 구현하지 말고, 검증 가능한 단위로 나누세요.

# 주문 시스템 구현을 단계별로 나눈 예시

Step 1: "Order Entity와 Repository를 만들어주세요. 
         엔티티 생성 후 ./gradlew test로 확인."

/clear

Step 2: "OrderService를 구현해주세요. 
         주문 생성, 조회, 취소 로직 포함.
         각 메서드에 대한 단위 테스트 작성."

/clear

Step 3: "OrderController를 구현해주세요.
         기존 UserController.kt 패턴을 따라주세요.
         통합 테스트 작성 후 전체 테스트 실행."

3.2 /clear를 적극적으로 사용

새 작업을 시작할 때마다 /clear로 컨텍스트를 초기화하세요. 컨텍스트가 쌓이면 Claude의 성능이 저하되고, 토큰 소비가 증가하며, 이전 대화의 실수가 반복될 수 있습니다. 컨텍스트 열화(context degradation)는 Claude Code 사용 시 가장 흔한 실패 원인입니다.

# 이렇게 하지 마세요 (한 세션에서 모든 것)
"Entity 만들어줘" → "Service도 추가" → "아 그리고 Controller도" → "테스트도..."

# 이렇게 하세요 (작업 단위별 세션 분리)
[세션 1] Entity + Repository + 테스트 → /clear
[세션 2] Service + 테스트 → /clear  
[세션 3] Controller + 통합 테스트 → /clear

3.3 기존 코드를 예시로 제공

Claude Code는 프로젝트의 기존 패턴을 보여줄 때 가장 일관된 코드를 생성합니다.

ProductController를 새로 만들어주세요.
기존 OrderController.kt의 패턴(에러 핸들링, 응답 형식, 페이지네이션)을 
그대로 따라주세요.

3.4 병렬 세션 활용

독립적인 작업은 여러 Claude Code 세션을 동시에 실행하여 병렬로 처리할 수 있습니다. VS Code 확장을 사용하면 여러 패널에서 동시에 인스턴스를 실행할 수 있습니다.

Writer/Reviewer 패턴:

세션역할작업

세션 A	Writer	API 엔드포인트 구현
세션 B	Reviewer	세션 A의 코드 리뷰 (편향 없이)

Test-First 패턴:

세션역할작업

세션 A	테스트 작성자	테스트 케이스 먼저 작성
세션 B	구현자	작성된 테스트를 통과하는 코드 구현

Phase 4: 품질 검증

4.1 자동 검증 루프

Claude Code가 스스로 검증하도록 구성하면, 사람이 피드백 루프에 개입할 필요가 줄어듭니다.

다음 순서로 진행해주세요:
1. OrderCancelService 구현
2. 단위 테스트 작성 및 실행
3. 테스트 실패 시 코드 수정 후 재실행
4. ./gradlew ktlintCheck로 스타일 검증
5. 전체 빌드 ./gradlew build 확인

4.2 MCP 통합으로 시각적 검증

MCP(Model Context Protocol) 서버를 연결하면 Claude가 브라우저, 콘솔 로그 등을 직접 확인할 수 있습니다.

Claude in Chrome: 실제 브라우저에서 UI를 열어 시각적 검증
Playwright MCP: 자동화된 브라우저 테스트 실행
Chrome DevTools MCP: 콘솔 로그와 네트워크 요청 확인

4.3 코드 리뷰 자동화

/install-github-app으로 Claude의 PR 자동 리뷰를 설정할 수 있습니다. 사람이 변수명을 지적하는 동안 Claude는 실제 로직 오류와 보안 이슈를 찾아냅니다.

yaml

# claude-code-review.yml
direct_prompt: |
  이 PR을 리뷰하고 버그와 보안 이슈만 보고해주세요.
  간결하게 작성하세요.
  코딩 스타일이나 변수명은 무시하세요.

Phase 5: Git 워크플로우 & 배포

5.1 커밋과 PR 자동화

Claude Code에게 Git 작업을 위임하면 시간을 절약하면서도 일관된 커밋 메시지를 유지할 수 있습니다.

# 변경사항을 Conventional Commits 형식으로 커밋
지금까지의 변경사항을 적절한 단위로 나눠서 커밋해주세요.
Conventional Commits 형식을 사용하세요.

# PR 생성
이 브랜치의 변경사항으로 PR을 만들어주세요.
- 제목: feat: 주문 취소 API 구현
- 본문에 변경 내용, 테스트 방법, 영향 범위를 포함

5.2 CI 파이프라인 연동

Claude Code를 CI/CD 파이프라인에서 비대화형(headless)으로 실행할 수 있습니다.

bash

# CI에서 자동 코드 수정 (린트 에러 등)
claude -p "린트 에러를 모두 수정해주세요" --allowedTools "Edit,Bash"

# 배치 작업
for issue in $ISSUES; do
  claude -p "이슈 $issue를 해결하고 PR을 생성해주세요"
done

핵심 원칙 요약

반드시 지켜야 할 것

CLAUDE.md를 꼼꼼히 작성하세요 — 투자 대비 효과가 가장 큰 단일 작업입니다.
코딩 전에 반드시 계획하세요 — Plan Mode로 아키텍처를 먼저 확정하세요.
검증 수단을 제공하세요 — 테스트, 린트, 빌드 명령을 Claude에게 알려주세요.
/clear를 습관화하세요 — 작업 전환 시 컨텍스트를 초기화하세요.
기존 패턴을 예시로 보여주세요 — 새 코드의 일관성이 크게 향상됩니다.
작업을 작게 나누세요 — 한 세션에 한 가지 작업만 집중하세요.

반드시 피해야 할 것

Kitchen Sink 세션 — 한 세션에서 관련 없는 여러 작업을 섞지 마세요.
모호한 프롬프트 — "API 만들어줘" 대신 구체적인 스펙을 제공하세요.
검증 없는 수락 — Claude가 생성한 코드를 반드시 빌드/테스트하세요.
MCP 서버 과다 연결 — 실제로 사용하는 것만 연결하세요 (4개 이내 권장).
코드 소유권 방기 — PR에 이름이 올라가는 것은 당신입니다. 최종 책임은 개발자에게 있습니다.

권장 워크플로우 치트시트

┌─────────────────────────────────────────────────┐
│  1. 인프라 세팅                                    │
│     CLAUDE.md 작성 → Rules 설정 → Hooks 구성       │
├─────────────────────────────────────────────────┤
│  2. 계획 수립 (Plan Mode)                          │
│     요구사항 분석 → 아키텍처 설계 → 계획 확인         │
├─────────────────────────────────────────────────┤
│  3. 단계별 구현                                    │
│     작업 분할 → 구현 → 검증 → /clear → 다음 작업    │
├─────────────────────────────────────────────────┤
│  4. 품질 검증                                      │
│     테스트 실행 → 린트 통과 → 빌드 확인              │
├─────────────────────────────────────────────────┤
│  5. Git 워크플로우                                  │
│     커밋 → PR 생성 → 코드 리뷰 → 머지               │
└─────────────────────────────────────────────────┘

참고 자료

[Flutter] Flutter에서 네이버 MAP API 연동 방법

더해리 — Mon, 27 Feb 2023 23:10:11 +0900

네이버지도를 플러터에서 띄울 수 있는 플러그인입니다.

Plug-in which shows naver map on flutter project support Android and iOS.

Install

해당 플러그인은 Naver Cloud PlatForm - map 에서 제공하는 map서비스를 Android와 iOS 환경에서 보여주는 플러그인입니다.

Naver cloud platform 에서 콘솔의 AI·Application Service > AI·NAVER API > Application에서 애플리케이션을 등록합니다.
등록한 애플리케이션을 선택해 Client ID값을 확인하고 변경 화면에서 Maps가 선택되어 있는지 확인한다.

pubspec.yaml에 plug in dependencies에 작성

dependencies:
  naver_map_plugin: ^0.9.6

Warning

지도에서 제공하는 기본 컨트롤러가 잘 작동하지 않는 문제 (이유를 찾지 못하고 있음)
android는 현 위치 버튼만 정상 작동

NOTICE (Android)

한국어
- 네이버에서 제공하는 SDK의 경우 안드로이드에서 지도를 표시하기 위해 기본값으로 GLSurfaceView를 사용한다. hot reload시에 naver map SDK의 binary에서 정확하지 않은 이유로 app crash가 발생한다. reload하지 않는 release version 에서는 성능이 더 좋은 GLSurfaceView를 사용하고, 아닌 경우 hot reload가 가능한 TextureView를 사용한다.
English
- NaverMap SDK use GLSurfaceView as default to flush map view in Android. At hot reload, App crash occurs in binary file of naver map SDK caused by unclear reason. if you build released version, this plug-in use GLSurfaceView for better performance, otherwise TextureView is used to make hot-reload available.

ANDROID GETTING START

Naver Cloud Platform - Android 시작 가이드

AndroidManifest.xml에 지정

<manifest>
    <application>
        <meta-data
            android:name="com.naver.maps.map.CLIENT_ID"
            android:value="YOUR_CLIENT_ID_HERE" />
    </application>
</manifest>

naver map에서 현위치탐색 기능을 사용하기 위해서는 AndroidManifest.xml에서 권한을 명시한다.

<manifest>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
</manifest>

또한 android API level 23(M) 이상의 경우 동적 권한을 필요로 한다. 다음은 동적권한을 요청하는 예제 코드이다.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 0);
    }
}

iOS GETTING START

Naver Cloud Platform - iOS 시작 가이드

대용량 파일을 받기 위해 git-lfs 설치가 필요합니다.

$ brew install git-lfs

그리고 git-lfs을 사용하기 위해 다음의 커맨드를 입력해주세요. lfs 사용 설정이 안될 경우 pod를 통한 dependency가 다운로드 되지않습니다.

$ git lfs install

info.plist에 지정

<dict>
  <key>NMFClientId</key>
  <string>YOUR_CLIENT_ID_HERE</string>
  <key>io.flutter.embedded_views_preview</key>
  <true/>
  <key>NSAllowsArbitraryLoads</key>
  <true/>
</dict>

naver map에서 현위치탐색 기능을 사용하기 위해서는 info.plist에서 권한을 명시한다.

<dict>
    <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
	<string>[USAGE PERPOSE]</string>
	<key>NSLocationAlwaysUsageDescription</key>
	<string>[USAGE PERPOSE]</string>
	<key>NSLocationWhenInUseUsageDescription</key>
	<string>[USAGE PERPOSE]</string>
</dict>

이후 AppDelefate에서 위치 사용권한을 획득하는 예제.

if (CLLocationManager.locationServicesEnabled()) {
    switch CLLocationManager.authorizationStatus() {
    case .denied, .notDetermined, .restricted:
        self.manager.requestAlwaysAuthorization()
        break
    default:
        break
    }
}

샘플 코드

import 'package:flutter/material.dart';

import 'package:naver_map_plugin_example/base_map.dart';
import 'package:naver_map_plugin_example/circle_map.dart';
import 'package:naver_map_plugin_example/padding_test.dart';
import 'package:naver_map_plugin_example/marker_map_page.dart';
import 'package:naver_map_plugin_example/path_map.dart';
import 'package:naver_map_plugin_example/polygon_map.dart';
import 'package:naver_map_plugin_example/text_field_page.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MainPage(),
    );
  }
}

class MainPage extends StatefulWidget {
  @override
  _MainPageState createState() => _MainPageState();
}

class _MainPageState extends State<MainPage> {
  List<String> menuText = [
    '기본 지도 예제',
    '마커 예제',
    '패스 예제',
    '원형 오버레이 예제',
    '컨트롤러 테스트',
    '폴리곤 예제',
    'GLSurface Thread collision test',
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        padding: EdgeInsets.all(16),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: menuText
              .map((text) => GestureDetector(
                    onTap: () => _onTapMenuItem(text),
                    child: Container(
                      margin: EdgeInsets.symmetric(vertical: 8),
                      padding: EdgeInsets.all(16),
                      decoration: BoxDecoration(
                        borderRadius: BorderRadius.circular(6),
                        border: Border.all(color: Colors.indigo),
                      ),
                      child: Text(
                        text,
                        style: TextStyle(
                          color: Colors.indigo,
                          fontSize: 12,
                          fontWeight: FontWeight.w600,
                        ),
                        textAlign: TextAlign.center,
                      ),
                    ),
                  ))
              .toList(),
        ),
      ),
    );
  }

  _onTapMenuItem(String text) {
    final index = menuText.indexOf(text);
    switch (index) {
      case 0:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => BaseMapPage(),
            ));
        break;
      case 1:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => MarkerMapPage(),
            ));
        break;
      case 2:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => PathMapPage(),
            ));
        break;
      case 3:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => CircleMapPage(),
            ));
        break;
      case 4:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => PaddingTest(),
            ));
        break;
      case 5:
        Navigator.push(
            context,
            MaterialPageRoute(
              builder: (_) => PolygonMap(),
            ));
        break;
      case 6:
        Navigator.push(
          context,
          MaterialPageRoute(
            builder: (_) => TextFieldPage(),
          ));
    }
  }
}

출처: https://pub.dev/packages/naver_map_plugin

Fiddler와 유사한 프로그램 리스트

더해리 — Sun, 12 Feb 2023 12:32:13 +0900

Charles: 웹 개발자용 HTTP 디버깅 프로그램으로, Fiddler와 비슷한 기능을 제공합니다.
Wireshark: 네트워크 패킷 분석 프로그램으로, Fiddler보다 복잡하지만 다양한 프로토콜을 분석할 수 있습니다.
Postman: API 개발 및 테스트용 프로그램으로, Fiddler와 달리 API 대상을 직접 테스트할 수 있습니다.
Burp Suite: 웹 애플리케이션 보안 테스트 프로그램으로, Fiddler와 비슷한 기능을 제공하며 보안 관련 기능도 제공합니다.

각 프로그램마다 다른 점이 있으니, 개인적인 요구에 맞는 프로그램을 선택하시면 됩니다.

[Flutter 3.0] Flutter 3.0 초기 환경 설정 on Windows

더해리 — Sun, 29 May 2022 18:19:56 +0900

Flutter SDK 다운로드

https://docs.flutter.dev/get-started/install/windows
최신 릴리즈 버전 다운로드(현재 3.0.1 최신)

명시적이고 간편한 경로에 압축을 해제합니다.(예: c:\src\flutter)

Flutter 기본 환경변수 PATH 설정

C:\src\flutter 기준

Windows 명령 프롬프트에서 flutter --version 실행해보자.

Flutter 3.0.1 표시되면 기본 PATH가 잘 설정된 것이다.

Flutter 개발 환경 준비(for Android)

Windows 명령 프롬프트에서 flutter doctor 실행해보자.

모든 개발 환경 준비가 잘 되어 있다면 "No issues found!" 메시지를 확인 할 수 있다.
준비되지 않은 체크 리스트는 해결 방법이 친절하게 제시되니 참고해서 해결하도록 하자

Flutter Doctor 이슈 해결방법

Android toolchain - Some Android licenses not accepted

Android 라이선스만 동의하면 쉽게 해결된다.
- flutter doctor --android-licenses 그대로 타이핑하자.

[야외맛집] 양산하얀집가든 미나리삼겹살/묵은지삼겹살

더해리 — Fri, 29 Oct 2021 01:42:00 +0900

하얀집가든 미나리삼겹살 : 네이버

육류,고기요리 · 매일 11:00 - 18:00, 야외 바베큐

m.place.naver.com

여름에는 수영장 펜션으로

푸짐하죠? ^^

묵은지와 삼겹살 그리고 버섯 꺄~

얼음컵 한가득 쉬원한 생맥주!

싱싱합니다.

먹고 또 먹고!

고기 먹고, 물놀이 하고, 고기 먹고, 물놀이하고~

자연 만끽~~~

야옹이들이 한가득~~

C++ 템플릿 Concept

더해리 — Tue, 12 Jan 2021 22:15:18 +0900

Concept의 개념

일반적으로 함수 템플릿(또는 클래스 템플릿)은 모든 타입이 아니라 특정 조건을 만족하는 타입에 대해서 동작하게 됨
타입이 가져야 하는 조건을 코드로 표현 한 것
2000년 중반부터 이야기 되었으나 아직 표준화 되지 않음
C++20 표준에 추가될 예정
Concept 문법이 도입될 경우 템플릿 코드에 많은 변화가 있게됨

#include <iostream>
using namespace std;

struct Point
{
    int x, y;
};

// 실제 파라미터가 모든 타입이 아닌 연산자 < 가능한 타입에 대해서만 지원하는 템플릿임
template<typename T> T Min(T x, T y)
{
    return y < x ? y : x;
}

int main()
{
    Point p1, p2;
    Min(p1, p2);
}

#include <iostream>
using namespace std;

struct Point
{
    int x, y;
    bool operator<(const Point& p) { return true; }
};

// 1. concept 만들기
template<typename T>
concept bool LessThanComparable = requires(T a, T b)
{
    { a < b }-- > bool;
};

// 2. template 만들때 concept 표기
template<typename T> requires LessThanComparable<T>
T Min(T x, T y)
{
    return y < x ? y : x;
}

// 3. template 만들때 T대신 concept 사용
LessThanComparable Min(LessThanComparable x, LessThanComparable y)
{
    return y < x ? y : x;
}

int main()
{
    Point p1, p2;
    Min(p1, p2);
}

C++ 템플릿 디자인 Typelist

더해리 — Sun, 10 Jan 2021 22:39:32 +0900

Typelist

값이 아닌 타입의 리스트를 보관하는 데이터 타입
템플릿 인자가 1개라도 Typelist를 활용하면 복수의 타입을 만들 수 있음

#include <iostream>
using namespace std;

// 값을 보관하지 않음
// 타입 2개를 보관함
template<typename T, typename U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

struct NullType {};

// 매크로 도입
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, Typelist<T2, Nulltype>>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, Typelist<T2, Typelist<T3, Nulltype>>>
#define TYPELIST_2(T1, T2, T3, T4) Typelist<T1, Typelist<T2, Typelist<T3, Typelist<T4, Nulltype>>>>

template<typename T> class xtuple {};

int main()
{
    xtuple<int> t1;

    Typelist<int, NullType> t1;
    Typelist<int, Typelist<int, NullType>> t2;
    Typelist<int, Typelist<int, Typelist<char, NullType>>> t3;
}

Typelist Length

타입리스트의 요소 수 구하기

#include <iostream>
using namespace std;

// 값을 보관하지 않음
// 타입 2개를 보관함
template<typename T, typename U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

struct NullType {};

// 매크로 도입
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, Typelist<T2, NullType>>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, Typelist<T2, Typelist<T3, NullType>>>
#define TYPELIST_4(T1, T2, T3, T4) Typelist<T1, Typelist<T2, Typelist<T3, Typelist<T4, NullType>>>>

// 1. 사용하는 모습을 보고 메인 템플릿 생성
template<typename T> struct Length;

// 2. 갯수를 구할 수 있도록 부분 특수화
template<typename T, typename U> struct Length<Typelist<T, U>>
{
    enum { value = Length<U>::value + 1 };
};

// 3. 재귀를 종료하기 위한 특수화
template<> struct Length<NullType>
{
    enum { value = 0 };
};

template<typename T> void test()
{
    cout << Length<T>::value << endl; // 4
}

int main()
{
    test<TYPELIST_4(int, int, double, float)>();
}

TypeAt

#include <iostream>
using namespace std;

// 값을 보관하지 않음
// 타입 2개를 보관함
template<typename T, typename U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

struct NullType {};

// 매크로 도입
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, Typelist<T2, NullType>>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, Typelist<T2, Typelist<T3, NullType>>>
#define TYPELIST_4(T1, T2, T3, T4) Typelist<T1, Typelist<T2, Typelist<T3, Typelist<T4, NullType>>>>


// Typelist의 N번째 요소의 타입 구하기
// 메인 템플릿
template<typename T, int N> struct TypeAt
{
    //typedef ? type;
};

// 원하는 타입을 구할 수 있도록 부분 특수화
// N == 0
template<typename T, typename U> struct TypeAt<Typelist<T, U>, 0>
{
    typedef T type;
};

// 원하는 타입을 구할 수 있도록 부분 특수화
// N != 0
template<typename T, typename U, int N> struct TypeAt<Typelist<T, U>, N>
{
    typedef typename TypeAt<U, N-1>::type type;
};

template<typename T> void test()
{
    typename TypeAt<T, 0>::type i; // int
    cout << typeid(i).name() << endl;

    typename TypeAt<T, 1>::type c; // char
    cout << typeid(c).name() << endl;

    typename TypeAt<T, 2>::type d; // double
    cout << typeid(d).name() << endl;

    typename TypeAt<T, 3>::type l; // long
    cout << typeid(l).name() << endl;
}

int main()
{
    test<TYPELIST_4(int, char, double, long)>();
}

Append

#include <iostream>
using namespace std;

// 값을 보관하지 않음
// 타입 2개를 보관함
template<typename T, typename U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

struct NullType {};

// 매크로 도입
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, Typelist<T2, NullType>>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, Typelist<T2, Typelist<T3, NullType>>>
#define TYPELIST_4(T1, T2, T3, T4) Typelist<T1, Typelist<T2, Typelist<T3, Typelist<T4, NullType>>>>

// Typelist 끝에 타입 추가하기
template<typename TL, typename T> struct Append;

// TL T
// 1. NullType, NullType => NullType
template<> struct Append<NullType, NullType>
{
    typedef NullType type;
};

// 2. NullType, 임의의 타입 => Typelist<임의의 타입, NullType>
template<typename T> struct Append<NullType, T>
{
    typedef Typelist<T, NullType> type;
};

// 3. NullType, Typelist<Head, Tail> = Typelist<Head, Tail>
template<typename Head, typename Tail> struct Append<NullType, Typelist<Head, Tail>>
{
    typedef Typelist<Head, Tail> type;
};

// 4. Typelist<Head, Tail>, NullType => Typelist<Head, Tail>
template<typename Head, typename Tail> struct Append<Typelist<Head, Tail>, NullType>
{
    typedef Typelist<Head, Tail> type;
};

// 5. Typelist<Head, Tail>, 임의의 타입 => Typelist<Head, Append<Tail, T>::type>
template<typename Head, typename Tail, typename T> struct Append<Typelist<Head, Tail>, T>
{
    typedef Typelist<Head, typename Append<Tail, T>::type> type;
};

template<typename T> void test()
{
    typename Append<T, int>::type t1;
    cout << typeid(t1).name() << endl; // int, char, double, int, NullType
}

int main()
{
    test<TYPELIST_3(int, char, double)>();
}

Typelist 예제

#include <iostream>
using namespace std;

// 값을 보관하지 않음
// 타입 2개를 보관함
template<typename T, typename U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

struct NullType {};

// 매크로 도입
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, Typelist<T2, NullType>>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, Typelist<T2, Typelist<T3, NullType>>>
#define TYPELIST_4(T1, T2, T3, T4) Typelist<T1, Typelist<T2, Typelist<T3, Typelist<T4, NullType>>>>

// Holder : 임의 타입의 data 1개 보관
template<typename T> struct Holder
{
    T value;
};

// GenScatterHierachy => MakeCode
template<typename T, template<typename> class Unit> 
class MakeCode : public Unit<T>
{
};

template<template<typename> class Unit> 
class MakeCode<NullType, Unit>
{
};

template<typename Head,             //            , Holder<double>,     empty 
    typename Tail,                  // Holder<int>, MakeCode<double, Unit>, MakeCode<NullType>
    template<typename> class Unit>  // MakeCode<int, Unit>, MakeCode<Typelist<double, NullType>, Unit
    
class MakeCode<Typelist<Head, Tail>, Unit> : public MakeCode<Head, Unit>, public MakeCode<Tail, Unit>
{
    // int value;
    // double value;
};

int main()
{
    // MakeCode의 1번째 인자가 Typelist일때
    MakeCode<TYPELIST_2(int, double), Holder> mc1;  // 기반 클래스 Holder<int>
                                // Holder<int>와 메모리 모양이 동일
    MakeCode<double, Holder> mc2; // Holder<double>
    MakeCode<NullType, Holder> mc3; // Empty
}

C++ 템플릿 디자인 Member Detect IDioms

더해리 — Sun, 10 Jan 2021 21:57:33 +0900

Member Detect IDioms

클래스의 멤버 타입 존재 여부 확인
클래스의 멤버 함수 존재 여부 확인

//컴파일 타임의 함수 시그니처에 대한 특성만 활용하는 특성을 이용하는 기법

// 함수 시그니처만 사용함으로 구현부가 없어도 괜찮음
char foo(int a);
short foo(double d);

int main()
{
    int n = 10;

    cout << sizeof(n) << endl; // 4
    //cout << sizeof(foo) << endl; // Error
    cout << sizeof(foo(3)) << endl; // 1
    cout << sizeof(foo(3.3)) << endl; // 2
}

#include <iostream>
#include <vector>
using namespace std;

// 멤버 타입을 가진 데이터용 템플릿(반환값이 char로 1바이트)
template<typename T> 
char check(typename T::value_type* a);

// 멤버 타입이 없는 데이터용 템플릿(반환값이 short로 2바이트)
template<typename T>
short check(...);

// 멤버 타입이 없는 데이터
struct NoValueType
{
};
// 멤버 타입이 있는 데이터
struct HasValueType
{
    typedef int value_type;
};

// 멤버 타입 존재를 여부 확인 함수
template<typename T>
struct has_value_type
{
    // 반환값이 char(1바이트)일때는 true, short(2바이트)일때는 false
    static constexpr bool value = (sizeof(check<T>(0)) == 1); 
};

int main()
{
    cout << has_value_type<HasValueType>::value << endl;
    cout << has_value_type<NoValueType>::value << endl;

    HasValueType t1;
    cout << sizeof(check<HasValueType>(0)) << endl;
    NoValueType t2;
    cout << sizeof(check<NoValueType>(0)) << endl;
}

#include <iostream>
#include <vector>
using namespace std;

// 멤버함수가 존재할 경우 
template<typename T> 
char check(decltype(T().resize(0))* a);

// 멤버함수가 존재하지 않을 경우
template<typename T>
short check(...);

// 멤버함수 존재 체크
template<typename T>
struct has_resize
{
    static constexpr bool value = (sizeof(check<T>(0)) == 1); 
};

int main()
{
    // vector는 resize가 있으므로 true 리턴
    cout << has_resize<vector<int>>::value << endl;
    
    // array는 resize가 없으므로 false 리턴
    cout << has_resize<array<int, 10>>::value << endl;
}

C++ 템플릿 디자인 SFINAE(Substitution Failure Is Not An Error)

더해리 — Sun, 10 Jan 2021 18:39:56 +0900

함수 찾는 순서

1순위 정확한 매칭(exactly matching)
2순위 템플릿(template)
3순위 가변 인자(variable argument)

#include <iostream>
using namespace std;

template<typename T>
// 2순위 템플릿(template)
void foo(T t) { cout << "T" << endl; }
// 1순위 정확한 매칭(exactly matching)
void foo(int n) { cout << "int" << endl; }
// 3순위 가변 인자(variable argument)
void foo(...) { cout << "..." << endl; }

int main()
{
    foo(3);
}

SFINAE

Substitution Failure Is Not An Error
함수 템플릿을 사용시 T의 타입이 결정되고 함수를 생성(Instantiation)하려고 할때 리턴 타입이나 함수 인자등에서 치환에 실패하면 컴파일 에러가 아니라, 함수 후보군에서 제외함
동일한 이름의 다른 함수가 있다면 다른 함수를 사용하게 됨

#include <iostream>
using namespace std;

template<typename T>
typename T::type foo(T t) 
{ 
    cout << "T" << endl; return 0; 
}

void foo(...) 
{ 
    cout << "..." << endl; 
}

int main()
{
    // 가변인자 함수보다 템플릿 함수가 우선순위가 높아서 먼저 참조하게 되지만 리턴 타입에서 
    // int 타입::type은 존재하지 않으므로 만족할 수 없으므로 후보군에서 제외되고 가변인자 버전의 함수가 사용됨
    foo(3); // T
}

enable_if

c++표준에서 지원하는 도구
1번째 인자가 true일 경우만 type이 정의됨
- enable_if<true, int>::type -> int
- enable_if<true>::type -> void
- enable_if<false, int>::type -> error
- enable_if<false>::type -> error

#include <iostream>
using namespace std;

template<bool b, typename T = void> struct enable_if
{
};

template<typename T> struct enable_if<true, T>
{
    typedef T type;
};

int main()
{
    //enable_if<true, int>::type t0; // 타입이 int로 결정
    //enable_if<true>::type t1; // 타입이 void로 결정
    //enable_if<false, int>::type t2; // 타입이 없어서 error
}

enable_if 예제

정수일때만 동작하는 함수를 만들고 싶을때
- static_assert
  - 처리하게 되면 조건을 만족하지 않을 경우 컴파일 에러
- enable_if
  - SFINAE 특성을 활용한 방법
  - 조건을 만족하지 않으면 함수를 생성하지 않고 다른 후보가 있다면 사용함
  - 확장성 유리

#include <iostream>
using namespace std;

// 정수일때만 함수 코드를 생성하고 싶음
template<typename T>
typename enable_if<is_integral<T>::value, int>::type
foo(T a)
{
    cout << "T" << endl;

    return 0;
}

void foo(...)
{
    cout << "not integer" << endl;
}

int main()
{
    foo(2.3);
}

enable_if 위치

함수 리턴 타입
함수 인자 타입 -> 생성자에서 주로 사용
템플릿 인자 -> 함수 자체의 모양이 단순해 보이는 장점 있음

#include <iostream>
using namespace std;

// 함수 리턴 타입 위치
template<typename T>
typename enable_if<is_integral<T>::value, int>::type
foo(T a)
{
    cout << "T" << endl;

    return 0;
}

// 함수 인자 타입 위치(리턴 타입이 없는 생성자에서 주로 사용)
template<typename T>
void foo(T a, 
    typename enable_if<
    is_integral<T>::value>::type* = nullptr)
{
    cout << "T" << endl;
}

// 템플릿 인자(함수 자체의 원형이 최대한 유지됨으로 간결해 보이는 장점)
template<typename T, 
    typename enable_if<
    is_integral<T>::value>::type* = nullptr>
void foo(T a)
{
    cout << "T" << endl;
}

// 모두 만족하지 않을때 호출
void foo(...)
{
    cout << "not integer" << endl;
}

int main()
{
    foo(2); // 템플릿 함수 호출(현재 예제코드는 3개의 템플릿이 만족함으로 에러 발생함)
    foo(2.3); // foo(...) 호출
}

타입의 종류에 따라 다르게 동작하는 함수 생성 방법

type_traits(is_pointer) + if constexpr // C++17에서만 가능
type_traits + 함수 오버로딩(false_type, true_type)
- 디스패치 함수 1개 더 필요
type_traits + enable_if

// C++17이상 가능 if constexpr 사용 방법

#include <iostream>
using namespace std;

template<typename T> void printv(const T& v)
{
    if constexpr(is_pointer<T>::value)
        cout << v << ":" << *v << endl;
    else
        cout << v << endl;
}

int main()
{
    int n = 0;
    printv(n);
    printv(&n);
}

// type_traits + 함수 오버로딩(false_type, true_type)

#include <iostream>
using namespace std;

template<typename T>
void printv_imp(const T& v, true_type)
{
    cout << v << ":" << *v << endl;
}

template<typename T>
void printv_imp(const T& v, false_type)
{
    cout << v << ":" << endl;
}

template<typename T> void printv(const T& v)
{
    printv_imp(v, is_pointer<T>());
}

int main()
{
    int n = 0;
    printv(n);
    printv(&n);
}

// type_traits + enable_if 사용 방법

#include <iostream>
using namespace std;

template<typename T> 
typename enable_if<is_pointer<T>::value>::type 
printv(const T& v)
{
    cout << v << ":" << *v << endl;
}

template<typename T> 
typename enable_if<!is_pointer<T>::value>::type
printv(const T& v)
{
    cout << v << ":" << endl;
}

int main()
{
    int n = 0;
    printv(n);
    printv(&n);
}

C++ 템플릿 디자인 단위 전략(Policy-Based Design)

더해리 — Sat, 9 Jan 2021 23:17:18 +0900

Policy Based Design

클래스가 사용하는 정책을 템플릿 인자를 통해서 교체 할 수 있게 만드는 디자인
성능 저하 없이 정책을 교체 할 수 있음
대부분의 정책은 담은 "단위 전략 클래스"는 지켜야 하는 규칙이 있음
- 규칙을 표현하는 코딩 방식은 없음(인터페이스 사용시 가상 함수이므로 약간의 오버헤드 발생), C++20 concept 문법
- 우리가 만든 동기화 정책클래스는 "lock/unlock" 함수가 필요함
- 템플릿 기반 라이브러리, 특히 STL에서 널리 사용되는 디자인 기법

#include <iostream>
using namespace std;

// 1개의 클래스로 정책 템플릿 인자를 통해서 다르게 구현 할 수 있도록 디자인
template<typename T, typename ThreadModel> class List
{
    ThreadModel tm;
public:
    void push_front(const T& a)
    {
        tm.lock();
        // 구현부 코드
        tm.unlock();
    }
};

// 싱글 쓰레드 기반 환경용
class NoLock
{
public:
    inline void Lock() {};
    inline void Unlock() {}
};

// 멀티 쓰레드 기반 환경용
class MutexLock
{
public:
    inline void Lock() {};
    inline void Unlock() {}
};

// 환경에 따라서 클래스 생성 시 전략을 선택 할 수 있음
// 싱글 쓰레드용 생성
//List<int, NoLock> s;
// 멀티 쓰레드용 생성
List<int, MutexLock> s;

int main()
{
    s.push_front(10);
}

STL allocator

C++에서 메모리 할당 방법은 다양함
- new, malloc, calloc, win32 api, linux system call
STL에서는 각 데이터 컨테이너의 템플릿 인자로 메모리 할당 방식에 대한 전략을 선택할 수 있도록 지원함

#include <iostream>
using namespace std;

// STL의 Vector 생각
// 메모리 할당기
template<typename T> class allocator
{
public:
    T* allocate() {}
    void deallocate() {}
};

template<typename T, typename Ax = allocator<T>> class vector
{
    T* buff;
    Ax ax;
public:
    void resize(int n)
    {
        // 버퍼 재할당이 필요하다면 어떻게 할까요?
        // new, malloc, calloc, win32 api, linux system call
        T* p = ax.allocate(n);
        ax.deallocate(p);
    }
};

int main()
{
    vector<int, MyAlloc<int>> v(10);
    v.resize(20);
}

rebind

#include <iostream>
using namespace std;

template<typename T> class allocator
{
public:
    T* allocate(int sz) { return new T[sz]; }
    void deallocate(T* p) { delete[] p; }

    template<typename U> struct rebind
    {
        typename allocator<U> other;
    };
};

template<typename T, typename Ax = allocator<T> > class list
{
    struct NODE
    {
        T data;
        NODE* next, * prev;
    };
    //Ax ax; // allocator<int>
    //allocator<int>::rebind<NODE>::other ax; // allocator<NODE> ax;
    typename Ax::template rebind<NODE>::other ax; // allocator<NODE> ax;
public:
    void push_front(const T& a)
    {
        ax.allocate(1);
    }
};

int main()
{
    list<int> s;
    s.push_front(10);
}

C++ 템플릿 디자인 패턴 CRTP 활용

더해리 — Fri, 8 Jan 2021 00:13:19 +0900

CRTP 활용한 싱글톤(Singleton) 만들기

싱글톤: 하나의 객체만 생성 할 수 있게 만드는 디자인 패턴
- private 생성자
- 복사와 대입 금지
- 하나의 객체를 만들어서 리턴하는 static 멤버 함수

단일 Singletone 패턴 클래스

#include <iostream>
using namespace std;

class Cursor
{
private:
    Cursor() {}
public:
    Cursor(const Cursor& c) = delete;
    void operator=(const Cursor& c) = delete;

    static Cursor& getInstance()
    {
        static Cursor instance;
        return instance;
    }

};

int main()
{
    Cursor& c1 = Cursor::getInstance();
    Cursor& c2 = Cursor::getInstance();
}

CRTP 패턴 Singleton 패턴 클래스

#include <iostream>
using namespace std;

template<typename T>
class Singleton
{
protected:
    Singleton() {}
public:
    Singleton(const Singleton& c) = delete;
    void operator=(const Singleton& c) = delete;

    static T& getInstance()
    {
        static T instance;
        return instance;
    }
};

class Mouse : public Singleton<Mouse>
{
};

int main()
{
    Mouse& m1 = Mouse::getInstance();
    Mouse& m2 = Mouse::getInstance();
}

CRTP 활용한 Unique한 기반 클래스 만들기

기반 클래스의 static memeber data는 모든 파생 클래스에 의해 공유됨
파생 클래스 별로 다른 static member data가 필요한 경우, 서로 다른 기반 클래스를 사용해야 함
CRTP를 사용하면 모든 파생 클래스 별로 다른 타입의 기반 클래스를 만들 수 있음

static 멤버 데이터를 관리하는 단일 클래스

#include <iostream>
using namespace std;

class Object
{
public:
    static int cnt;

    Object() { ++cnt; }
    ~Object() { --cnt; }

    static int getCount() { return cnt; }
};
int Object::cnt = 0;

int main()
{
    Object c1, c2;
    cout << c1.getCount() << endl;
}

static 멤버 데이터를 관리하는 유일한 기반 클래스

#include <iostream>
using namespace std;

template<typename T>
class Object
{
public:
    static int cnt;

    Object() { ++cnt; }
    ~Object() { --cnt; }

    static int getCount() { return cnt; }
};
template<typename T> int Object<T>::cnt = 0;

class Mouse : public Object<Mouse>
{

};

class Keyboard : public Object<Keyboard>
{

};

int main()
{
    Mouse m1, m2;
    Keyboard k1, k2;
    cout << m1.getCount() << endl;
    cout << k1.getCount() << endl;
}

C++ 템플릿 디자인 패턴 CRTP(Curiously Recurring Template Pattern) 패턴

더해리 — Thu, 7 Jan 2021 23:17:50 +0900

CRTP(Cruiously Recurring Template Pattern) 활용

기반 클래스에서 파생 클래스의 이름을 사용할 수 있게 하는 기법
파생 클래스를 만들때 기반 클래스의 템플릿 인자로 파생 클래스 이름을 전달

기준 코드

메인 함수 호출 시 기반 클래스의 OnClick 함수가 호출됨
파생 클래스의 OnClick 함수를 호출하기 위해서는?

#include <iostream>
using namespace std;

class Window
{
public:
    void msgLoop()
    {
        OnClick();
    }
    void OnClick() { cout << "Window OnClick" << endl; }
};

class FrameWindow : public Window
{
public:
    void OnClick() { cout << "FrameWindow OnClick" << endl; }
};

int main()
{
    FrameWindow fw;
    fw.msgLoop(); // OUTPUT : Window OnClick
}

구현 코드

비 가상 함수(Non virtual function)를 가상 함수 처럼 동작하게 함
파생 클래스를 만들때 기반 클래스의 템플릿 인자로 파생 클래스 이름을 전달
- this 포인터를 파생 클래스 타입으로 캐스팅 후 함 수 호출

#include <iostream>
using namespace std;

template<typename T>
class Window
{
public:
    void msgLoop()
    {
        // this 포인터를 파생 클래스인 T 타입으로 캐스팅 후 호출    
        static_cast<T*>(this)->OnClick();
    }
    //가상함수로 만들면 가상함수 테이블이 관리됨
    void OnClick() { cout << "Window OnClick" << endl; }
};

class FrameWindow : public Window<FrameWindow>
{
public:
    void OnClick() { cout << "FrameWindow OnClick" << endl; }
};

int main()
{
    FrameWindow fw;
    fw.msgLoop(); // OUTPUT : FrameWindow OnClick
}

C++ 템플릿 패턴 Thin template, 코드 메모리 최적화 기법

더해리 — Thu, 7 Jan 2021 22:45:10 +0900

thin template

템플릿의 단점 중 한가지는 코드 메모리의 증가
모바일등 메모리가 부족한 환경에서 사용할 수 있는 기법

기준 코드

4개의 함수 구성 * 3개의 타입 사용 = 총 12개의 함수 생성

#include <iostream>
using namespace std;

template<typename T> class Vector
{
    T* buff;
    int sz;
public:
    int size() const {}
    bool empty() const {}
    void push_front(const T& a) {}
    T& front() {}
};

int main()
{
    Vector<int> v1;
    Vector<short> v2;
    Vector<double> v3;
}

T를 사용하지 않는 모든 멤버를 기반클래스에 정의하고 상속받아서 구현

2개의 함수 구성 * 3개의 타입 사용 + 기반 클래스 함수 2개 = 총 8개의 함수 생성

#include <iostream>
using namespace std;

class VectorBase
{
protected:
    int sz;
public:
    int size() const {}
    bool empty() const {}
};

template<typename T> class Vector : public VectorBase
{
    T* buff;
public:
    void push_front(const T& a) {}
    T& front() {}
};

int main()
{
    Vector<int> v1;
    Vector<short> v2;
    Vector<double> v3;
}

모든 멤버를 기반 클래스로 구현

모든 T는 void*로 변경
void*를 바로 사용하면 캐스팅이 불편함으로 캐스팅을 책임지는 파생 클래스를 템플릿으로 제공

#include <iostream>
using namespace std;

class VectorBase
{
protected:
    void* buff;
    int sz;
public:
    int size() const {}
    bool empty() const {}
    void push_front(const void* a) {}
    void* front() {}
};

// void*를 바로 사용하면 캐스팅의 불편함이 있음
// 캐스팅을 책임지는 파생 클래스를 템플릿으로 제공
// 캐스팅만 책임지는 함수는 inline로 치환하면 함수화 되지 않음
template<typename T> class Vector : public VectorBase
{
public:
    inline void push_front(const T& a) { VectorBase::push_front(static_cast<void*>(a)) }
    inline T& front() { return static_cast<T&>(VectorBase::front()); }
};

int main()
{
    Vector<int> v1;
    Vector<short> v2;
    Vector<double> v3;
}

기반 클래스 멤버를 직접 호출 방지를 위해 private 상속으로 변경

#include <iostream>
using namespace std;

class VectorBase
{
protected:
    void* buff;
    int sz;
public:
    int size() const {}
    bool empty() const {}
    void push_front(const void* a) {}
    void* front() {}
};

// void*를 바로 사용하면 캐스팅의 불편함이 있음
// 캐스팅을 책임지는 파생 클래스를 템플릿으로 제공
template<typename T> class Vector : private VectorBase
{
public:
    int size() const { return VectorBase::size(); }
    bool empty() const { return VectorBase::empty(); }
    inline void push_front(const T& a) { VectorBase::push_front(static_cast<void*>(a)); }
    inline T& front() { return static_cast<T&>(VectorBase::front()); }
};

int main()
{
    Vector<int> v1;
    Vector<short> v2;
    Vector<double> v3;
}

C++ 가변인자 템플릿(Variadic template) tuple 전체 요소 출력

더해리 — Thu, 7 Jan 2021 21:58:39 +0900

가변인자 템플릿(Variadic template)를 활용하여 tuple 전체 요소를 출력

#include <iostream>
#include <tuple>
using namespace std;

//튜플과 index_sequence를 받아서 튜플 전체 요소를 출력
template<typename TP, size_t ... I> 
void print_tuple_imp(const TP& tp, const index_sequence<I...>&)
{
    int x[] = { get<I>(tp)... };

    for (auto& n : x)
        cout << n << ", ";
}

template<typename TP>
void print_tuple(const TP& tp)
{
    // 튜플 사이즈를 구해서 index_sequence를 생성하여 print_tuple_imp에 전달
    print_tuple_imp(tp, make_index_sequence<tuple_size<TP>::value>());
}

int main()
{
    tuple<int, int, int> tp(1, 2, 3);

    print_tuple(tp);
}

C++ 가변인자 템플릿(Variadic template) tuple을 위한 get 구현

더해리 — Thu, 7 Jan 2021 00:11:53 +0900

기반 클래스의 멤버에 접근하는 방법(기반 지식)

기반 클래스의 멤버와 파생클래스의 멤버의 이름이 동일할때는 자신(파생 클래스)의 멤버가 우선
기반 클래스의 멤버에 접근하는 방법
- d.Base::value
- static_cast<Base&>(d).value;
값 캐스팅과 참조 캐스팅
- static_cast<Base>(d): 임시객체 생성. lvalue가 될 수 없음
- static_cast<Base&>(d): 임시객체를 생성 안함. lvalue가 될 수 있음

#include <iostream>
using namespace std;

struct Base
{
    int value = 10;
};

struct Derived : public Base
{
    int value = 20;
};

int main()
{
    Derived d;

    cout << d.value << endl; // 20
    cout << d.Base::value << endl; // 10

    cout << static_cast<Base>(d).value << endl; // 10 임시객체 생성
    cout << static_cast<Base&>(d).value << endl; // 10 참조

    //static_cast<Base>(d).value = 30; // Error
    static_cast<Base&>(d).value = 30; // OK

}

Tuple_element

tuple이 가진 N번째 요소의 타입을 구하는 템플릿
메인 템플릿(Main template) 생성, 구현은 불필요함으로 생략
0번째 요소를 구하는 부분 특수화 구현
N번째 요소를 구하는 부분 특수화 구현(Recursive)

#include <iostream>
using namespace std;

// tuple 메인 템플릿
template<typename ... Types> struct xtuple
{
    static constexpr int N = 0;
};

// tuple 부분 특수화
template<typename T, typename ... Types> 
struct xtuple<T, Types...> : public xtuple<Types...> // 타입을 상속을 통해 재귀 저장 효과
{
    T value;
    xtuple() = default; // 기본 생성자
    xtuple(const T& v, const Types& ... args) 
        : value(v), xtuple<Types...>(args...) {} // Pack expansion으로 가변인자 전달

    static constexpr int N = xtuple<Types...>::N + 1;
};

// 메인 템플릿
template<size_t N, typename TP> struct xtuple_element;

// 요소의 타입을 구할 수 있도록 부분 특수화
template<typename T, typename... Types> struct xtuple_element<0, xtuple<T, Types...>>
{
    typedef T type;
    typedef xtuple<T, Types...> tupleType;
};

// 요소의 타입을 구할 수 있도록 부분 특수화
template<size_t N, typename T, typename... Types> 
struct xtuple_element<N, xtuple<T, Types...>>
{
    typedef typename xtuple_element<N-1, xtuple<Types...>>::type type;
    typedef typename xtuple_element<N-1, xtuple<Types...>>::tupleType tupleType;
};

// xtuple 요소를 꺼내는 함수
template<size_t N, typename TP>
typename xtuple_element<N, TP>::type& xget(TP& tp)
{
    return static_cast<typename xtuple_element<N, TP>::tupleType&>(tp).value;
}

int main()
{
    xtuple<int, double, char> t3(1, 3.4, 'A'); // 1
    
    cout << xget<1>(t3) << endl; // 3.4
    xget<1>(t3) = 1.1;
    cout << xget<1>(t3) << endl; // 1.1
}

C++ 가변인자 템플릿(Variadic template) tuple 만들기

더해리 — Wed, 6 Jan 2021 23:11:03 +0900

tuple C++11 표준

서로 다른 타입의 객체를 N개 보관하는 템플릿

#include <iostream>
#include <tuple>
using namespace std;

int main()
{
    tuple<> t0;
    tuple<int> t1(1);
    tuple<int, double, int, char> t4(1, 3.4, 2, 'A');

    get<2>(t4) = 15; // 참조 리턴으로 값 변경 가능

    cout << get<2>(t4) << endl; // 2
}

tuple 만들기

가변인자 템플릿을 사용해서 메인 템플릿(Main template)을 만듬
1개의 요소를 보관할 수 있도록 부분 특수화 구현
상속을 사용해서 N개를 보관할 수 있게 구현
생성자등 필요한 멤버 추가

#include <iostream>
using namespace std;

// tuple 메인 템플릿
template<typename ... Types> struct xtuple
{
    static constexpr int N = 0;
};

// tuple 부분 특수화
template<typename T, typename ... Types> 
struct xtuple<T, Types...> : public xtuple<Types...> // 타입을 상속을 통해 재귀 저장 효과
{
    T value;
    xtuple() = default; // 기본 생성자
    xtuple(const T& v, const Types& ... args) 
        : value(v), xtuple<Types...>(args...) {} // Pack expansion으로 가변인자 전달

    static constexpr int N = xtuple<Types...>::N + 1;
};

int main()
{
    xtuple<> t0;
    xtuple<int> t1(3);
    xtuple<int, double, char> t4(1, 3.4, 'A');
}

C++ 가변인자 템플릿(Variadic template) 함수 인자타입 구하기

더해리 — Wed, 6 Jan 2021 22:40:06 +0900

함수의 인자 타입을 구하는 traits 만들기

메인 템플릿(Main template)만들고 typedef T type 제공
함수 타입인 T 안에 있는 함수 인자 타입을 얻을 수 있도록 부분 특수화
- T -> R(A1, A2), T -> R(A1, Types...)
N번째 인자 타입 구하는 방법
- 0번째 인자의 타입을 구하는 부분 특수화 작성
- N번째 인자의 타입을 구하는 부분 특수화 작성
  - N == 0이 될때까지 Recursive 사용
  - Recuresive 사용시, 함수의 0번째 인자를 제거하고 N-1 사용
    - argument_type<3, R(A1, A2, A3, A4))::type
      - argument_type<2, R(A1, A2, A3, A4))::type
        
        argument_type<1, R(~~A1, A2~~, A3, A4))::type
        
        argument_type<0, R(~~A1, A2, A3~~, A4))::type

#include <iostream>
#include <vector>
#include <type_traits>
using namespace std;

double hoo(short a, int b, double c) { return 0; }

// 메인 템플릿
template<size_t N, typename T> struct argument_type
{
    typedef T type;
};

// 0번째 인자의 타입을 구하는 부분 특수화 작성
template<typename T, typename A1, typename ... Types> 
struct argument_type<0, T(A1, Types ...)>
{
    typedef A1 type;
};

// N번째 인자의 타입을 구하는 부분 특수화 작성
template<size_t N, typename R, typename A1, typename ... Types> 
struct argument_type<N, R(A1, Types ...)>
{
    typedef
        typename argument_type<N - 1, R(Types...)>::type type;
};

template<typename T> void foo(const T& t)
{
    // T : double(short, int, double)
    typename argument_type<0, T>::type ret;
    cout << typeid(ret).name() << endl;
}

int main()
{
    foo(hoo);
}

C++ 가변인자 템플릿(Variadic template) 함수 리턴타입 구하기

더해리 — Wed, 6 Jan 2021 22:06:49 +0900

함수 정보를 구하는 traits 만들기

메인 템플릿(Primary template)을 만들고 typedef T type 제공
함수 타입의 T안에 있는 리턴 타입을 얻을 수 있도록 부분 특수화 구현
부분 특수화를 할땡 가변인자 템플릿을 활용

#include <iostream>
#include <vector>
#include <type_traits>
using namespace std;

double hoo(short a, int b) { return 0; }

// 메인 템플릿
template<typename T>
struct result_type
{
    typedef T type;
};

// 함수 타입에 대한 부분 특수화, 가변인자 활용
template<typename T, typename ... Types>
struct result_type<T(Types ... args)>
{
    typedef T type;
};

template<typename T> void foo(const T& t)
{
    // T : double(short, int) 함수 모양
    typename result_type<T>::type ret;
    cout << typeid(ret).name() << endl;
}

int main()
{
    foo(hoo);
}

traits 잘못 사용할때 처리 방법

메인 템플릿에서 typedef T type을 제공하지 않는 방법
메인 템플릿에서 static_assert()를 사용해서 명시적 에러 메시지 출력
메인 템플릿의 선언만 구현

#include <iostream>
#include <vector>
#include <type_traits>
using namespace std;

double hoo(short a, int b) { return 0; }

// 1. typedef T type 미제공
template<typename T>
struct result_type
{
};

// 2. static_assert()를 사용해서 에러 메시지 출력
template<typename T>
struct result_type
{
    static_assert(is_function<T>::value, "Not supported type");
};

// 3. 선언부만 제공
template<typename T>
struct result_type;


// 함수 타입에 대한 부분 특수화
template<typename T, typename ... Types>
struct result_type<T(Types ... args)>
{
    typedef T type;
};

template<typename T> void foo(const T& t)
{
    // T : double(short, int) 함수 모양
    typename result_type<T>::type ret;
    cout << typeid(ret).name() << endl;
}

int main()
{
    foo(hoo);
}

C++ 가변인자 템플릿(Variadic template), fold expression(C++17)

더해리 — Wed, 6 Jan 2021 00:34:50 +0900

Parameter Pack 각 요소 꺼내기

Pack Expansion -> array or tuple에 담기

#include <iostream>
#include <tuple>
using namespace std;

template<typename ... Types> 
void foo(Types ... args)
{
    // 각각의 타입별 값을 tuple 개별 요소로 추가
    tuple<Types...> tp(args...);

    cout << get<0>(tp) << endl;
    cout << get<1>(tp) << endl;
    cout << get<2>(tp) << endl;
}


int main()
{
    foo(1, 3.4, "AA");
}

재귀 호출과 유사한 호출식을 사용하기
- 1번째 인자는 이름 있는 변수 2번째 인자는 가변 인자로 구현

#include <iostream>
#include <tuple>
using namespace std;

void foo() {} // 재귀 호출 종료용

template<typename T, typename ... Types>
void foo(T value, Types ... args)
{
    cout << value << endl;
    foo(args...); 
    // 아래처럼 반복 호출 됨
    // foo(3.4, "AA");
    // foo("AA");
    // foo();
}


int main()
{
    foo(1, 3.4, "AA"); // value : 1, args : 3.4, "AA"
}

fold expression(C++17)

이항 연산자를 사용해서 parameter pack안에 있는 요소에 연산을 수행하는 문법
parameter pack의 이름에서 ... 붙이지 않고 사용
- pack expansion : args...
- fold expression : args + ...
4가지 형태(args:1,2,3,4)
- unary right fold: ( args op ... )
  - (args + ... ) // 1+(2+(3+4))
- unary left fold : (... op args)
  - (... + args) // ((1+2)+3)+4
- binary right fold : ( args op ... op init)
  - ( args + ... + 10) // 1+(2+3(4+10)))
- binary left fold : ( init op ... op args)
  - (10 + ... + args) // (((10+1)+2)+3)+4

#include <iostream>
using namespace std;

template<typename ... Types>
void foo(Types ... args)
{

    // args 값을 모두 호출할 수 있음
    //binary left fold : ( init op ... op args)
    (cout << ... << args);
}

int main()
{
    foo(1, 2, 3);
    (((cout << 1) << 2) << 3);
}

#include <iostream>
#include <vector>
using namespace std;

vector<int> v;

template<typename ... Types>
void foo(Types ... args)
{
    (v.push_back(args), ...);
    for (auto n : v)
        cout << n << endl;
}

int main()
{
    foo(1, 2, 3);
    (((cout << 1) << 2) << 3);
}

C++ 가변인자 템플릿(Variadic template)

더해리 — Tue, 5 Jan 2021 23:30:13 +0900

가변인자 템플릿(Variadic template)

C++11부터 지원되는 문법
가변인자 템플릿(클래스 템플릿, 함수 템플릿)의 기본 모양
가변인자 템플릿의 인자 "Types"는 여러개의 타입을 나타냄
가변인자 함수 템플릿의 인자인 "args"안에는 여러개의 값이 들어있고 "Parameter Pack"이라고 함

#include <iostream>
using namespace std;

// 가변인자 클래스 템플릿.
template<typename ... Types> class tuplex
{

};

// 가변인자 함수 템플릿
template<typename ... Types>
void foo(Types ... args)
{

}

int main()
{
    // 가변인자 클래스 템플릿(타입 생략, 복수의 타입까지...)
    tuplex<> t0p;
    tuplex<int> t1;
    tuplex<int, char> t2;
    
    // 가변인자 함수 템플릿(인자 생략, 복수의 인자까지...)
    foo();
    foo(1);
    foo(1, 3.4, "A");
}

Parameter Pack

가변인자 템플릿으로 전달받은 파라미터 집합을 Parameter Pack이라 함
sizeof...(args), sizeof...(Types) 함수를 이용해서 Parameter Pack 요소의 갯수를 얻어 올 수 있음
goo(args...); 받은 Parameter Pack을 다시 전달할때 요소 전체를 풀어쓰는 방법을 Pack Expansion이라 함

#include <iostream>
using namespace std;

// Pack expansion을 통해 Parameter Pack을 전달 받을 함수
void goo(int n, double d, const char* s)
{
    cout << "goo : " << n << ", " << d << ", " << s << endl;
    // 1, 3.4, "AAA"
}

// 가변인자 함수 템플릿
template<typename ... Types>
void foo(Types ... args)
{
    // args : Parameter Pack
    
    cout << sizeof...(args) << endl; // 3
    cout << sizeof...(Types) << endl; // 3

    //goo(args); // Error
    goo(args...); // Pack expansion
                  // goo( 1, 3.4, "AAA")
}

int main()
{
    //foo();
    //foo(1);
    foo(1, 3.4, "AAA"); 
        // Types : int, double, const char*
        // args : 1, 3.4, "AAA"

}

Pack Expansion

Parameter Pack을 사용하는 패턴에 "..." 붙이면 해당 패턴이 ',' 구분자로 확장되는 형태임
args이 1, 2, 3을 가지고 있을때
- args... -> 1, 2, 3
- (--args)... -> 0, 1, 2
- func(args)... -> func(1), func(2), func(3)
- func(args...) -> func(1, 2, 3)
- func2(func(args...)) -> func2(func(1, 2, 3))
- func2(func(args)...)) -> func2(func(1), func(2), func(3))
Pack Expansion은 함수 호출 인자 또는 list 초기화를 사용한 표현식에서만 사용할 수 있음
- 배열 이용
  - 컴파일러에 따라 빈값이 허용 안될 수 있으므로 첫번째 요소를 더미로 0으로 지정
  - 함수가 반환 타입이 void 경우 대비해서 대체 반환값 (x, 0) 패턴 사용
    - int x[] = { 0, (print(args), 0)... };
- 초기화 리스트 이용
  - 빈값이 허용 됨으로 배열에 비해서 첫번째 요소 더미 0을 생략 할 수 있음
  - initializer_list<int> e = { (print(args), 0)... };

#include <iostream>
using namespace std;

void goo(int n, double d, const char* s)
{
    cout << "goo : " << n << " " << d << " " << s << endl;
}

int hoo(int a) { return -a; }

int print(int a)
{
    cout << a << ", ";
    return 0;
}

template<typename ... Types>
void foo(Types ... args)
{
    int x[] = { args... }; // Pack expansion
    for (auto n : x)
        cout << n << endl;

    //print(args); // Error(함수 호출 인자 or list 초기화가 아님)
    //print(args...); // Error(함수 호출 인자 or list 초기화가 아님)
    //print(args)...; // Error(함수 호출 인자 or list 초기화가 아님)

    // 배열 이용
    int ea[] = { 0, (print(args), 0)... };

    // 초기화 리스트 이용
    initializer_list<int> ei = { (print(args), 0)... };

}

int main()
{
    foo(1, 2, 3);
     // Types : int, int, int
     // args : 1, 2, 3
}

Expansion 예제

#include <iostream>
using namespace std;

template<typename ... Types> void foo(Types ... args)
{
    // Types : int, double

    int x[] = { args... };
    pair<Types...> p1; // pair<int, double> // OK
    tuple<Types...> t1; // tuple<int, double> // OK

    tuple<pair<Types...>> t2; // tuple<pair<int, double>> // OK
    tuple<pair<Types>...> t3; // tuple<pair<int>, pair<double>> // Error

    tuple<pair<int, Types>...> t4; // tuple<pair<int, int>, pair<int, double>> // OK

    pair<tuple<Types...>> p2; // pair<tuple<int, double>> // Error
    pair<tuple<Types>...> p3; // pair<tuple<int>, tuple<double>> // OK

}

int main()
{
    foo(1, 3.4); 
      // args : 1, 3.4
      // Types : int, double
}

C++ 템플릿 type_traits(C++11 표준 remove_pointer, is_pointer)

더해리 — Mon, 4 Jan 2021 22:53:01 +0900

C++11 표준 type traits

변형된 타입을 얻는 traits
- typename remove_pointer<T>::type;
- remove_pointer_t<T> n; // C++14
타입의 정보를 조사하는 traits
- bool b = is_pointer<T>::value;
- bool b = is_pointer_v<T>; // C++17
- 함수 오버로딩 사용(true_type, false_type) 활용
간소화된 버전
- C++14 기본 제공
  - remove_pointer_t<T> n;
- C++17 기본 제공
  - bool b = is_pointer_v<T>;

#include <iostream>
#include <type_traits>
using namespace std;

//using을 사용해서 간소화 가능
template<typename T>
using remove_pointer_type = typename remove_pointer<T>::type;

// C++17에서는 variable template을 사용해서 간소화 가능
//template<typename T>
//inline constexpr bool is_pointer_v = is_pointer<T>::value;

template<typename T> void foo(T a)
{
    // 포인터를 제거한 타입 반환
    typename remove_pointer<T>::type rawType;
    remove_pointer_type<T> rawType2;

    // 포인터 타입 여부 확인
    bool isPointer = is_pointer<T>::value;
}
int main()
{
    int n = 0;
    foo(&n);
}

C++11 표준 type_traits 예제

is_array<T>::value : 배열 확인
extent<T, 0>::value : 배열 각 차원의 요소 수
is_same<T, U>::value : 타입 같음 비교
remove_cv<T, U>::type : const, volatile 속성 제거(타입 비교시 이용)
decay<T, U>::type : 배열을 포인터화 사용 필요 시

#include <iostream>
#include <type_traits>
using namespace std;

// 배열 정보 조사하기
// array => pointer : decay
template<typename T> void foo(T& a)
{
    if (is_array<T>::value)
    {
        cout << "array" << endl;

        cout << extent<T, 0>::value << endl;
        cout << extent<T, 1>::value << endl;
    }
}

template<typename T, typename U> void hoo(T a, U b)
{
    // 두 타입 비교
    bool ret1 = is_same<T, U>::value;

    // 배열일 경우 포인터화 비교
    bool ret2 = is_same<typename decay<T>::type, typename decay<U>::type>::value;

    // const, volatile 제거 후 비교
    bool ret3 = is_same<typename remove_cv<T>::type, typename remove_cv<U>::type>::value;

    cout << ret1 << endl;
    cout << ret2 << endl;
    cout << ret3 << endl;
}

int main()
{
    int x = 1;
    const int cx = 1;
    int* xp = &x;
    int a[3][2] = { 1,2,3,4,5,6 };
    foo(a);
    hoo(x, cx);
}

C++ 템플릿 traits(함수 반환 값/파라미터)

더해리 — Mon, 4 Jan 2021 22:28:25 +0900

함수의 리턴타입, 인자타입 정보를 구하는 traits 만들기

메인 템플릿(Main template)을 만들고 typedef T type 제공(C++11 using 동일)
부분 특수화(Partial specialization)를 통한 원하는 타입을 얻을 수 있도록 T 타입 분할
- 함수 타입 T(double(short, int))를 리턴타입 double과 인자타입(short, int)로 분리
- T(double(short, int)) -> R(A1, A2)
메인 템플릿의 활용도가 없을 경우 내부 type은 제거 해도 됨

#include <iostream>
using namespace std;

double hoo(short a, int b) { return 0; }

// 반환 타입에 대한 메인 템플릿
template<typename T> 
struct result_type
{
    typedef T type;
};

// 함수타입에 대한 부분 특수화
template<typename T, typename A1, typename A2> 
struct result_type<T(A1, A2)>
{
    typedef T type;
};

// 인자는 복수개이므로 N 파라미터 추가로 필요
template<typename T, size_t N>
struct argument_type
{
    typedef T type;
};

// 첫번째 인자에 대한 부분 특수화
template<typename R, typename A1, typename A2>
struct argument_type<R(A1, A2), 0>
{
    typedef A1 type;
};

// 두번째 인자에 대한 부분 특수화
template<typename R, typename A1, typename A2>
struct argument_type<R(A1, A2), 1>
{
    typedef A2 type;
};

template<typename T> void foo(T& t)
{
    // T : double(short, int)
    typename result_type<T>::type ret_type;
    typename argument_type<T, 0>::type arg_type0;
    typename argument_type<T, 1>::type arg_type1;

    cout << typeid(ret_type).name() << endl; // double
    cout << typeid(arg_type0).name() << endl; // short
    cout << typeid(arg_type1).name() << endl; // int
}
int main()
{
    foo(hoo);
}

C++11 표준의 함수 리턴 타입 구하기

result_of(C++17 미만)
invoke_result(C++17 이상)
decltype 사용해서 구현(일반함수, 함수 객체, 람다표현식등의 모든 callable object 고려)

C++ 템플릿 type modification(remove_pointer)

더해리 — Mon, 4 Jan 2021 22:15:45 +0900

type traits 기능(C++11)

type에 대한 query : is_pointer<>, is_array<>, extent<>
type에 대한 변형 타입 : remove_pointer<>, add_pointer<>

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T> void foo(T a)
{
    bool b = is_pointer<T>::value;
    typename remove_pointer<T>::type t;
    
    cout << typeid(t).name() << endl;
}

int main()
{
    int n = 10;
    foo(n);
    foo(&n);
}

remove_pointer 구현 예제

remove_pointer_custom 메인 템플릿 생성
- int -> int 반환
remove_pointer_custom 부분 특수화(Partial specialization) 생성
- int* -> int 반환

#include <iostream>
using namespace std;

// Main template
template<typename T> 
struct remove_pointer_custom
{
    typedef T type;
};

// Partial specialization
template<typename T> 
struct remove_pointer_custom<T*>
{
    typedef T type;
};

template<typename T> void foo(T a)
{
    // 값이 아닌 타입을 꺼낼때는 typename을 꼭 사용 필요
    typename remove_pointer_custom<T>::type t;

    cout << typeid(t).name() << endl;
}

int main()
{
    int n = 10;
    foo(&n);
}

remove_all_pointer 구현 예제

중첩 포인터까지 모두 제거 되는 remove_pointer 구하는 방법

#include <iostream>
using namespace std;

template<typename T> 
struct remove_all_pointer_custom
{
    typedef T type;
};

template<typename T> 
struct remove_all_pointer_custom<T*>
{
    // 포인터 타입일때까지 포인터를 제거하며 자기 자신을 호출하고 최종 메인 템플릿이 호출됨
    typedef typename remove_all_pointer_custom<T>::type type;
};

int main()
{
    typename remove_all_pointer_custom<int**>::type n;
    cout << typeid(n).name() << endl;
}

C++ 템플릿 integral_constant

더해리 — Sun, 3 Jan 2021 23:36:35 +0900

integral_constant

컴파일 타임에 결정된 상수 값을 별도 타입화 하여 함수 오버로딩을 할 수 있도록 만드는 int2type 기술
int2type 기술을 C++11에서 표준화한 integral_constant

기본 함수 오버로딩(Function overloading)

이자의 개수가 다르거나 인자 타입이 다르면 아래와 같이 인수에 따라 서로 다른 함수가 호출 되게 할 수 있음
인자가 개수가 같고 인자의 타입도 같을때 다른 함수가 되게 하려면?

#include <iostream>
using namespace std;

void foo(int n) {}
void foo(double d) {}

int main()
{
    foo(1); // foo(int)
    foo(1.2); // foo(double)
}

int2type

컴파일 타임 정수형 상수를 각각의 독립된 타입으로 만드는 기술
int2type을 사용하면 컴파일 타임에 결정된 정수형 상수를 모두 다른 타입으로 만들 수 있음
- 1, 2는 같은 타입이지만, int2type<1>, int2type<2>는 다른 타입
int2type을 함수 오버로딩에 사용하거나 템플릿 인자, 상속등에 사용할 수 있음

#include <iostream>
using namespace std;

// 같은 정수형 타입이지만 값에 따라 별도의 타입으로 생성
template<int N> struct int2type
{
    static constexpr int value = N;
};

int main()
{
    int2type<1> t0; // int2type<1> 타입
    int2type<2> t1; // int2type<2> 타입
}

int2type 예제

printv 함수에서 받은 값의 포인터 타입 여부에 따라 분기처리 코드가 작성되어 값과 포인터 참조값을 출력하도록 되어 있음
포인터 여부는 컴파일 타임에 체크되지만 if 구문이 런타임 조건문으로 하위 코드들은 모두 컴파일 대상
포인터가 아닌 값에 대해서는 사용할 수 없는 구분이 포함되어 간접 참조 에러가 발생함
간접 참조 에러가 발생하는 구문을 별도의 함수 템플릿으로 분리함
각 함수 템플릿은 int2type을 활용하여 인자 타입으로 구분하여 사용
동일 이름을 가지는 함수가 여러개 있을때, 어느 함수를 호출할지는 컴파일 타임에 결정됨
호출이 결정되지 않은 템플릿은 instantiation 되지 않음

#include <iostream>
using namespace std;

// 포인터 타입 체크용 메인 템플릿
template<typename T> struct is_pointer_custom
{
    //enum { value = false }; 
    static constexpr bool value = false; // c++11
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T*>
{
    //enum { value = true };
    static constexpr bool value = true; // c++
};
...

// 같은 정수형 타입이지만 값에 따라 별도의 타입으로 생성되는 타입 도구
template<int N> struct int2type
{
    static constexpr int value = N;
};

// 컴파일 타임 상수 값 구분용 함수 템플릿
template<typename T>
void printv_imp(T v, int2type<1>)
{
    cout << v << " : " << *v << endl;
}

// 컴파일 타임 상수 값 구분용 함수 템플릿
template<typename T>
void printv_imp(T v, int2type<0>)
{
    cout << v << endl;
}

// 값을 받아서 출력하고, 포인터일 경우 포인터의 값까지 출력
template<typename T> void printv(T v)
{
    // 아래의 조건으로 분기 코드 작성시 if 구문이 런타임 조건문으로
    // 포인터가 아닌 값에 대해서 컴파일 에러 발생
    //if(is_pointer_custom<T>::value)
    //    cout << v << " : " << *v << endl;
    //else
    //    cout << v << endl;

    // 출력 구현부를 별도로 분리하여 함수 템플릿으로 타입을 구분하여 문제 해결 가능
    printv_imp(v, int2type<is_pointer_custom<T>::value>());
    // is_pointer_custom 반환 값에 의해(포인터: int2type<1>, 포인터 아님: int2type<0> 타입)
}

int main()
{
    int n = 3;
    printv(n);
    printv(&n);
}

integral_constant 예제

int뿐 아니라 모든 정수 계열 상수 값을 타입으로 만들 수 있게 하는 템플릿(실수는 템플릿 인자 사용X)
- bool, char, short, int, long, long long
true_type, false_type
- true/false: 참 거짓을 나타내는 값, 서로 같은 타입
- true_type/false_type: 참 거짓을 나타내는 값, 서로 다른 타입
is_pointer등의 type_traits를 만들때 intergral_constant를 기반 클래스로 사용하여 간소화 및 가독성을 높일 수 있음
- T가 포인터가 아니라면, value = false, 기반 클래스는 false_type
- T가 포인터라면, value = true, 기반 클래스는 true_type

#include <iostream>
using namespace std;

template<typename T, T N> 
struct integral_constant
{
    static constexpr T value = N;
};

// int 타입 0, 1 서로 다른 타입
integral_constant<int, 0> t0;
integral_constant<int, 1> t1;

// short 타입, 0, 1 서로 다른 타입
integral_constant<short, 0> s0;
integral_constant<short, 1> s1;

// bool 타입, true, false 서로 다른 타입
integral_constant<bool, true> tb1;
integral_constant<bool, false> tb0;

// bool 타입은 활용 빈도가 높으므로 true_type, false_type 별칭 만들어서 사용
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;

template<typename T>
struct is_pointer : false_type
{
    // false_type 상속으로 아래 코드 생략
    //static constexpr bool value = false;
};

template<typename T>
struct is_pointer<T*> : true_type
{
    // true_type 상속으로 아래 코드 생략
    //static constexpr bool value = true;
};

C++11 type_traits 활용하여 int2type 예제 간소화

C++11 <type_traits>헤더 포함
int2type<0>, int2type<1> -> integral_constant<0>, integral_constant<1>
integral_constant<0>, integral_constant<1> -> false_type, true_type

#include <iostream>
#include <type_traits>
using namespace std;

// 컴파일 타임 상수 값 구분용 함수 템플릿
template<typename T>
void printv_imp(T v, true_type)
{
    cout << v << " : " << *v << endl;
}

// 컴파일 타임 상수 값 구분용 함수 템플릿
template<typename T>
void printv_imp(T v, false_type)
{
    cout << v << endl;
}

// 값을 받아서 출력하고, 포인터일 경우 포인터의 값까지 출력
template<typename T> void printv(T v)
{
    printv_imp(v, is_pointer<T>());
}

int main()
{
    int n = 3;
    printv(n);
    printv(&n);
}

C++17 if constexpr를 사용하여 컴파일 타임에 분기처리 가능

#include <iostream>
#include <type_traits>
using namespace std;

// 값을 받아서 출력하고, 포인터일 경우 포인터의 값까지 출력
template<typename T> void printv(T v)
{
    if constexpr(is_pointer<T>::value)
        cout << v << " : " << *v << endl;
    else
        cout << v << endl;
}

int main()
{
    int n = 3;
    printv(n);
    printv(&n);
}

c++ 템플릿 type_traits 배열 타입 체크(is_array)

더해리 — Sun, 3 Jan 2021 18:48:10 +0900

is_array 예제

간단히 템플릿 파라미터 T가 배열 타입 여부 확인 도구
메인 템플릿(Main template)에서 false 반환( value = false )
배열 타입 부분 특수화(Partial specialization)에서 true 반환( value = true )
타입을 정확히 알아야 함
- int x[3]; 에서 x는 변수 이름, 변수 이름을 제외한 나머지 요소(int[3])이 타입임
unknown size array type(T[])에 대해서도 부분 특수화가 필요함

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T> struct is_array_custom
{
    static constexpr bool value = false;
};

// 크기를 알 수 있는 배열의 부분 특수화
template<typename T, size_t N>
struct is_array_custom<T[N]>
{
    static constexpr bool value = true;
};

// 크기를 알 수 없는 배열의 부분 특수화
template<typename T, size_t N>
struct is_array_custom<T[N]>
{
    static constexpr bool value = true;
};

template<typename T> void foo(T& a)
{
    // 크기를 알 수 있는 배열 확인
    if (is_array_custom<T>::value)
        cout << "array" << endl;
    else
        cout << "not array" << endl;
      
    // 크기를 알 수 없는 배열을 사용하는 패턴도 존재함
    //if (is_array_custom<int[]>::value)
}

int main()
{
    int x[3] = { 1, 2, 3 };
    foo(x);
}

is_array 배열 크기 구하기

부분 특수화로 배열의 크기도 구할 수 있음
- c++11 extent<T, 0>::value 존재

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T> struct is_array_custom
{
    static constexpr bool value = false;
    static constexpr size_t size = -1;
};

//사이즈를 알 수 있는 배열에 대한 부분 특수화에서 N이 배열의 크기
template<typename T, size_t N>
struct is_array_custom<T[N]>
{
    static constexpr bool value = true;
    static constexpr size_t size = N;
};

template<typename T> void foo(T& a)
{
    if (is_array_custom<T>::value)
        cout << "size of array : " << is_array_custom<T>::size << endl;
}

int main()
{
    int x[3] = { 1, 2, 3 };
    foo(x);
}

c++ 템플릿 type_traits 포인터 타입 체크(is_pointer)

더해리 — Sun, 3 Jan 2021 18:17:11 +0900

type traits 개념

컴파일 타임에 타입에 대한 정보를 얻거나 변형된 타입을 얻을때 사용하는 도구(메타 함수)
<type_traits> 헤더로 제공됨(c++11)

type query를 위한 type traits 만드는 방법

메인 템플릿(Primary template)에서 false 반환( value = false )
부분 특수화(Partial specialization)에서 true 반환( value = true )

is_pointer 예제

간단히 템플릿 파라미터 T가 포인터 타입 여부 확인 도구
메인 템플릿(Primary template)에서 false 반환( value = false )
포인터 타입용 부분 특수화(Partial specialization)에서 true 반환( value = true )

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T> struct is_pointer_custom
{
    enum { value = false }; 
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T*>
{
    enum { value = true };
};

template<typename T> void foo(T v)
{
    if (is_pointer_custom<T>::value)
        cout << "pointer" << endl;
    else
        cout << "not pointer" << endl;
}

int main()
{
    int n = 3;
    foo(n);
    foo(&n);
}

is_pointer 개선 예제

c++11 기준 코드 개선
좀더 다양한 포인터 타입 지원(const, volatile, const volatile)

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T> struct is_pointer_custom
{
    //enum { value = false }; 
    static constexpr bool value = false; // c++11
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T*>
{
    //enum { value = true };
    static constexpr bool value = true; // c++
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T* const>
{
    //enum { value = true };
    static constexpr bool value = true; // c++
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T* volatile>
{
    //enum { value = true };
    static constexpr bool value = true; // c++
};

// 포인터 타입에 대해서 부분 특수화 필요
template<typename T> struct is_pointer_custom<T* const volatile>
{
    //enum { value = true };
    static constexpr bool value = true; // c++
};

int main()
{
    cout << is_pointer_custom<int>::value << endl;
    cout << is_pointer_custom<int*>::value << endl;
    cout << is_pointer_custom<int* const>::value << endl;
    cout << is_pointer_custom<int* volatile>::value << endl;
    cout << is_pointer_custom<int* const volatile>::value << endl;
    cout << is_pointer_custom<int* volatile const>::value << endl;
}

C++ 템플릿 constexpr 함수(constexpr function)

더해리 — Sun, 3 Jan 2021 11:57:38 +0900

constexpr 함수

함수앞에 constexpr 붙이면 파라미터가 컴파일 타임 상수 일 경우 함수를 컴파일 시간에 연산(성능 이점)
일반 변수 파라미터 입력시 일반 함수처럼 동작

#include <iostream>
#include <type_traits>
using namespace std;

template<int N> struct Check
{

};

// constexpr 함수(c++11)
constexpr int add(int a, int b)
{
    return a + b;
}

int main()
{
    int n1 = 1, n2 = 2;

    int n = add(n1, n2);   // OK(일반 변수 파라미터 입력 시 일반 함수처럼 동작)
    int m = add(1, 2);     // OK(컴파일 타임 상수 파라미터 입력 시 컴파일 타임에 연산)
    Check<add(1, 2)> c;    // OK(컴파일 타임에 연산됨으로 템플릿 파라미터로 사용 가능)
    Check<add(n1, n2)> c2; // Error(일반 함수처럼 동작하므로 템플릿 파라미터로 사용 불가)
}

C++ 템플릿 메타 프로그래밍(Template meta programming)

더해리 — Sun, 3 Jan 2021 10:58:32 +0900

템플릿 메타 프로그래밍

컴파일 시간에 연산을 수행하는 개념
템플릿 파라미터 5를 받았을때 5 * 4 * 3 * 2 * 1 값을 반환하는 Factorial 구현

#include <iostream>
#include <type_traits>
using namespace std;

//  템플릿 메타 프로그래밍(template meta programming)
template<int N> struct Factorial
{
    enum { value = N * Factorial<N-1>::value };
};

// 재귀의 종료를 위해 특수화(Specialization)
template<> struct Factorial<1>
{
    enum { value = 1 };
};

int main()
{

    int n = Factorial<5>::value; // 5 * 4 * 3 * 2 * 1 => 120
    // 5 * Factorial<4>::value
    // 4 * Factorial<3>::value
    // 3 * Factorial<2>::value
    // 2 * Factorial<1>::value
    // 1

    cout << n << endl;
}

C++11 이후 부터는 enum대신 constexpr을 사용할 수 있다.

#include <iostream>
#include <type_traits>
using namespace std;

//  템플릿 메타 프로그래밍(template meta programming)
template<int N> struct Factorial
{
    //enum { value = N * Factorial<N-1>::value };
    static constexpr int value = N * Factorial<N - 1>::value;
};

// 재귀의 종료를 위해 특수화(Specialization)
template<> struct Factorial<1>
{
    //enum { value = 1 };
    static constexpr int value = 1;
};

int main()
{

    int n = Factorial<5>::value; // 5 * 4 * 3 * 2 * 1 => 120
    // 5 * Factorial<4>::value
    // 4 * Factorial<3>::value
    // 3 * Factorial<2>::value
    // 2 * Factorial<1>::value
    // 1

    cout << n << endl;
}

C++ 템플릿 특수화 예제(Tuple)

더해리 — Sun, 3 Jan 2021 01:35:59 +0900

XTuple(Couple 선형화 구현)

Couple 재귀 호출 대신 선형 호출 할 수 있는 패턴 지원
- Couple<int, Couple<int, double>...> -> XTuple<int, int, double...> 형태로 개선
Null 클래스 활용(Empty class)
- 멤버 없는 클래스
- 크기는 항상 1(sizeof(Null))
- 멤버는 없지만 타입이므로 함수 오버로딩이나 템플릿 인자로 활용
상속 활용 기술
개수의 제한을 없앨 수 없을까? C+++ Variadic template

#include <iostream>
#include <type_traits>
using namespace std;

template<typename T, typename U> struct Couple
{
    T v1;
    U v2;

    enum { N = 2 };
};

// 빈 파라미터로 활용하기 위한 empty class
struct Null {};

// 2개이상 5개 미만의 타입전달
template<typename P1,
typename P2,
typename P3 = Null,
typename P4 = Null,
typename P5 = Null> 
class XTuple 
    : public Couple<P1, XTuple<P2, P3, P4, P5, Null>>
{

};

// XTuple 상속을 종료하기 위한 특수화
template<typename P1, typename P2>
class XTuple<P1, P2, Null, Null, Null>
    : public Couple<P1, P2>
{

};

int main()
{
    // Couple을 선형화하여 XTuple 형태로 사용
    XTuple<int, char, long, short, double> t5;
}

C++ 템플릿 특수화 예제(Couple)

더해리 — Sun, 3 Jan 2021 01:01:37 +0900

Couple

2개의 인자로 받은 데이터를 보관하는 컨테이너
인자로 Couple 타입도 전달 가능
부분 특수화(Partial specialization)를 할때 파라미터 수를 잘 선택해야함
파라미터로 자기 자신을 재귀로 입력 시 N 표현 방법 고려
1번째 인자, 2번째 인자, 모든 인자가 Couple 일 경우 특수화 방법 고려

#include <iostream>
#include <type_traits>
using namespace std;

// 보관 데이터 수를 출력하는 함수
template<typename T> void printN(const T& cp)
{
    cout << T::N << endl;
}

// 2개의 인자를 보관하는 데이터(메인 템플릿)
template<typename T, typename U> struct Couple
{
    T v1;
    U v2;

    enum { N = 2 };
};

// 2번째 인자가 Couple일 경우
template<typename A, typename B, typename C>
struct Couple<A, Couple<B, C>>
{
    A v1;
    Couple<B, C> v2;
    enum { N = Couple<B, C>::N + 1 };
};

// 1번째 인자가 Couple일 경우
template<typename A, typename B, typename C>
struct Couple<Couple<A, B>, C>
{
    Couple<A, B> v1;
    C v2;
    enum { N = Couple<A, B>::N + 1 };
};

// 1번째, 2번째 모든 인자가 Couple일 경우
template<typename A, typename B, typename C, typename D>
struct Couple<Couple<A, B>, Couple<C, D>>
{
    Couple<A, B> v1;
    Couple<C, D> v2; 
    enum { N = Couple<A, B>::N + Couple<C, D>::N };
};

int main()
{
    // 2개의 인자 데이터
    Couple<int, double> c2;
    
    // 2번째 인자에 Couple 데이터를 입력 할 경우(총 3개 보관)
    // 가변 영역의 데이터는 int, int, char 총 3개
    Couple<int, Couple<int, char>> c3;
    
    // 2번째 인자의 Couple 데이터의 2번째 인자에 다시 Couple 데이터를 입력 할 경우(총 4개 보관)
    // Couple 데이터를 중첩하여 사용하였으나 가변 영역은 동일하게 int, int, T로 총 3개
    Couple<int, Couple<int, Couple<int, char>>> c4;
    
    // 1번째, 2번째 인자 모두 Couple 데이터를 입력 할 경우(총 4개 보관)
    Couple<Couple<int, int>, Couple<int, int>> c5;

    // 보관 데이터 수 출력
    printN(c2);
    printN(c3);
    printN(c4);
    printN(c5);
}