动态获取参数类型的默认值

import inspect

def example_function(param1, param2=None):
    pass

sig = inspect.signature(example_function)

for name, param in sig.parameters.items():
    if param.default != inspect.Parameter.empty:
        print(f"{name} has default value {param.default}")

param2 has default value None

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class Example {
    public static void exampleMethod(String param1, Integer param2) {
        // ...
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Example.class.getMethod("exampleMethod", String.class, Integer.class);
        for (Parameter parameter : method.getParameters()) {
            if (parameter.isNamePresent()) {
                String name = parameter.getName();
                if (parameter.isAnnotationPresent(DefaultValue.class)) {
                    DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class);
                    String defaultString = defaultValue.value();
                    System.out.println(name + " has default value " + defaultString);
                }
            }
        }
    }
}

param2 has default value 0

#include<iostream>
#include <type_traits>

template<typename T>
struct DefaultValue {
    static constexpr T value = T();
};

template <>
struct DefaultValue<int> {
    static constexpr int value = 0;
};

template <>
struct DefaultValue<double> {
    static constexpr double value = 0.0;
};

template<typename T>
void exampleFunction(T param1, T param2 = DefaultValue<T>::value) {
    std::cout << "param1: "<< param1 << ", param2: "<< param2<< std::endl;
}

int main() {
    exampleFunction<int>(1);
    exampleFunction<double>(2.0);
    return 0;
}

param1: 1, param2: 0
param1: 2.0, param2: 0