cpp23-import-std-guide

KO | EN

gitlite — search

#python #android #rust #deep-learning #docker #nodejs #macos #java #windows #cli #kubernetes #awesome-list #pytorch #open-source

cpp23-import-std-guide

(★ 24)

Complete guide for C++23 import std; with GCC 15.1 and CMake 4.1. Includes the critical CXX_MODULE_STD property that most guides miss.

cpp23-import-std-guide 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# C++23 `import std;` with GCC 15.1 and CMake 4.1 - Complete Working Guide

**Save yourself days of pain!** This guide provides the exact configuration needed to make `import std;` work with GCC 15.1 and CMake 4.1.

## 🚨 TL;DR - The Magic Configuration

If you just want it to work, here's the exact setup:

### Root CMakeLists.txt:
```cmake
cmake_minimum_required(VERSION 4.1)

# THIS IS CRITICAL - Enable experimental import std support
set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "d0edc3af-4c50-42ea-a356-e2862fe7a444")

project(YourProject)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_SCAN_FOR_MODULES ON)
```

### For EVERY target using `import std;`:
```cmake
set_target_properties(YourTarget PROPERTIES
    CXX_STANDARD 23
    CXX_STANDARD_REQUIRED ON
    CXX_EXTENSIONS OFF
    CXX_MODULE_STD 1  # ← THIS IS THE KEY PROPERTY THAT EVERYONE MISSES!
)

target_compile_options(YourTarget PRIVATE -fmodules-ts)
```

## 🎯 Requirements

- **GCC 15.1+** (with libstdc++ module support)
- **CMake 4.1+** (for experimental std import)
- **C++23 standard**
- **Ninja** (recommended build system)

## 📁 Complete Working Example

### Project Structure:
```
project/
├── CMakeLists.txt          # Root configuration
├── Library1/
│   ├── CMakeLists.txt      # Library with CXX_MODULE_STD 1
│   └── math_lib.cppm       # Module using import std
├── App1/
│   ├── CMakeLists.txt      # App with CXX_MODULE_STD 1
│   └── main.cpp            # Uses import std + custom module
└── App2/
    ├── CMakeLists.txt      # Another app
    └── main.cpp
```

### Root CMakeLists.txt:
```cmake
cmake_minimum_required(VERSION 4.1)

# Enable experimental import std support for GCC 15.1
set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "d0edc3af-4c50-42ea-a356-e2862fe7a444")

project(ModulesExample)

# Set C++23 standard and enable modules
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_SCAN_FOR_MODULES ON)

# Set build type to Debug for debugging
if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Debug)
endif()

# Add subdirectories
add_subdirectory(Library1)
add_subdirectory(App1)
add_subdirectory(App2)
```

### Library1/CMakeLists.txt:
```cmake
add_library(Library1)

# Add module interface
target_sources(Library1
    PUBLIC
        FILE_SET CXX_MODULES FILES
            math_lib.cppm
)

# CRITICAL: Set C++23 standard and CXX_MODULE_STD property
set_target_properties(Library1 PROPERTIES
    CXX_STANDARD 23
    CXX_STANDARD_REQUIRED ON
    CXX_EXTENSIONS OFF
    CXX_MODULE_STD 1  # ← Without this, import std; will fail!
)

# GCC 15.1 specific module flags
target_compile_options(Library1 PUBLIC -fmodules-ts)
```

### Library1/math_lib.cppm:
```cpp
// Module interface using import std
export module math_lib;

import std;  // This works with proper CMake configuration!

export namespace MathLib {
    int add(int a, int b) {
        return a + b;
    }
    
    void print_result(std::string_view operation, int result) {
        std::cout << std::format("{} result: {}\n", operation, result);
    }
}
```

### App1/CMakeLists.txt:
```cmake
add_executable(App1 main.cpp)

# Link with the library
target_link_libraries(App1 PRIVATE Library1)

# CRITICAL: Must set CXX_MODULE_STD 1 for any target using import std
set_target_properties(App1 PROPERTIES
    CXX_STANDARD 23
    CXX_STANDARD_REQUIRED ON
    CXX_EXTENSIONS OFF
    CXX_MODULE_STD 1  # ← This is required for import std; to work!
)

# GCC 15.1 specific module flags
target_compile_options(App1 PRIVATE -fmodules-ts)
```

### App1/main.cpp:
```cpp
// Using both import std and custom modules
import std;      // Full standard library access
import math_lib; // Custom module

int main() {
    std::println("Hello from modern C++23!");
    
    int result = MathLib::add(10, 5);
    MathLib::print_result("Addition", result);
    
    // Use modern C++23 features
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::println("Vector size: {}", numbers.size());
    
    return 0;
}
```

## 🔧 Build Commands

```bash
# Configure (GCC 15.1 must be default or specified)
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -G Ninja

# Build (std module built automatically by CMake)
cmake --build build

# Run
./build/App1/App1
./build/App2/App2
```

## 🚨 Common Errors and Solutions

### Error: "unknown compiled module interface: no such module"
```
import std;
^~~~~~
```
**Solution**: Add `CXX_MODULE_STD 1` to target properties. This is the most common mistake!

### Error: "CMake 3.28 required"
**Solution**: You need CMake 4.1+ for experimental import std support.

### Error: "unrecognized command-line option '-stdlib=libstdc++'"
**Solution**: Don't use Clang flags with GCC. Use only `-fmodules-ts`.

### Error: Module compilation but linking fails
**Solution**: Ensure all targets that use `import std;` have `CXX_MODULE_STD 1` property.

## 🎯 Key Points That Save Hours

1. **`CXX_MODULE_STD 1`** - This property is not well documented but absolutely required
2. **CMake 4.1+** - Earlier versions don't support experimental import std
3. **Exact UUID** - The experimental feature UUID must be exact
4. **Every target** - Every target using `import std;` needs the property, not just the root
5. **C++23** - C++20 is not sufficient for full std module support

## 🧪 Testing Your Setup

Create this minimal test to verify everything works:

### test_import_std.cpp:
```cpp
import std;

int main() {
    std::println("import std; is working!");
    
    std::vector<int> v = {1, 2, 3};
    std::println("Vector has {} elements", v.size());
    
    auto result = std::format("Formatted: {}", 42);
    std::println(result);
    
    return 0;
}
```

### test/CMakeLists.txt:
```cmake
add_executable(test_import_std test_import_std.cpp)

set_target_properties(test_import_std PROPERTIES
    CXX_STANDARD 23
    CXX_STANDARD_REQUIRED ON
    CXX_EXTENSIONS OFF
    CXX_MODULE_STD 1  # Critical!
)

target_compile_options(test_import_std PRIVATE -fmodules-ts)
```

If this builds and runs, your setup is correct!

## 🔍 Troubleshooting

### Check GCC Version and Modules Support:
```bash
g++ --version  # Should be 15.1+
g++ -fmodules-ts -xc++ -std=c++23 -c /dev/null  # Should not error
```

### Check CMake Version:
```bash
cmake --version  # Should be 4.1+
```

### Verbose Build for Debugging:
```bash
cmake --build build --verbose
# Look for -fmodules-ts flags and std module compilation
```

## 📚 VS Code Integration

### .vscode/tasks.json:
```json
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "CMake Build",
            "type": "shell",
            "command": "cmake",
            "args": ["--build", "build"],
            "group": {"kind": "build", "isDefault": true},
            "presentation": {"echo": true, "reveal": "always"}
        }
    ]
}
```

### .vscode/launch.json:
```json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug App",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/build/App1/App1",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "preLaunchTask": "CMake Build",
            "miDebuggerPath": "/usr/bin/gdb"
        }
    ]
}
```

## 🎉 What You Get

With this setup working, you can use:
- `import std;` - Complete standard library as module
- `std::println()` - Modern C++23 print function
- `std::format()` - Advanced string formatting  
- Custom modules with clean interfaces
- Fast incremental compilation
- Full debugging support in VS Code

## 🤝 Share This Guide

Please share this with other C++ developers! The combination of:
- Missing `CXX_MODULE_STD 1` property
- Experimental CMake feature with specific UUID
- Need for CMake 4.1+ (not just 3.28)

...has caused countless hours of frustration. Let's save the community time!

## 📝 License

This configuration guide is provided under CC0 - use it freely to help other developers!

---

**Keywords for searchability**: GCC 15.1, CMake 4.1, import std, C++23, modules, CXX_MODULE_STD, CMAKE_EXPERIMENTAL_CXX_IMPORT_STD, std module, unknown compiled module interface

cpp23-import-std-guide

cpp23-import-std-guide 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

cpp23-import-std-guide

cpp23-import-std-guide 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README