如何构造带参数的真实整型类型？Bash参数展开技术问询

1. Constructing a Parameterized Real Integer Type #

A parameterized integer type lets you define constraints or properties (like bit width, valid value ranges) as parameters when creating the type. Implementation varies by language—here are practical examples for common scenarios:

Example 1: C++ Template for Bit-Specific Integers #

If you need an integer type with a fixed bit width (e.g., 8-bit, 32-bit), use a template class to enforce size at compile time:

#include <type_traits>

template<int BitSize>
class ParamInt {
private:
    // Select the smallest unsigned type that fits the desired bit size
    using UnderlyingType = typename std::conditional_t<
        BitSize <= 8, uint8_t,
        typename std::conditional_t<
            BitSize <= 16, uint16_t,
            typename std::conditional_t<
                BitSize <= 32, uint32_t, uint64_t
            >
        >
    >;
    UnderlyingType value;

public:
    explicit ParamInt(UnderlyingType val) : value(val) {}

    // Basic arithmetic operator example
    ParamInt operator+(const ParamInt& other) const {
        return ParamInt(value + other.value);
    }

    UnderlyingType get() const { return value; }
};

// Usage:
ParamInt<8> byteInt(255); // 8-bit unsigned integer
ParamInt<32> wordInt(4294967295); // 32-bit unsigned integer

Example 2: Python Class with Range Constraints #

For dynamic languages like Python, create a class that takes min/max parameters to enforce valid integer ranges:

class ParamInt:
    def __init__(self, value, min_val=None, max_val=None):
        if not isinstance(value, int):
            raise TypeError("Value must be an integer")
        if min_val is not None and value < min_val:
            raise ValueError(f"Value cannot be less than {min_val}")
        if max_val is not None and value > max_val:
            raise ValueError(f"Value cannot exceed {max_val}")
        self.value = value
        self.min_val = min_val
        self.max_val = max_val

    def __add__(self, other):
        if isinstance(other, ParamInt):
            new_val = self.value + other.value
        elif isinstance(other, int):
            new_val = self.value + other
        else:
            raise TypeError("Unsupported operand type for +")
        return ParamInt(new_val, self.min_val, self.max_val)

    def __repr__(self):
        return f"ParamInt({self.value}, min={self.min_val}, max={self.max_val})"

// Usage:
age = ParamInt(25, min_val=0, max_val=120)
print(age + 5) # Output: ParamInt(30, min=0, max=120)

2. Indirect Parameter Expansion in Bash #

Your goal is to use a variable to reference a command-line argument position (e.g., position=1 should pull $1). Bash supports indirect parameter expansion for exactly this use case.

Solution: Use ${!variable} Syntax #

Replace $position with ${!position} to tell Bash to first expand the variable's value, then use that as the parameter name. Here's your modified script:

#!/usr/local/bin/bash
position=1
echo "Parameter: ${!position}"

Running bash question.sh test will output Parameter: test—exactly what you want.

How It Works #

• $position expands directly to the string "1" (the value stored in the variable).
• ${!position} performs indirect expansion: it takes the value of position ("1"), treats it as a parameter name, and expands to the value of that parameter ($1).

Alternative (Less Safe): Use eval #

You can also use eval, but this is risky if position might contain untrusted input (it can execute arbitrary commands):

#!/usr/local/bin/bash
position=1
eval echo "Parameter: \$$position"

Stick with ${!variable} for safer, cleaner code.

内容的提问来源于stack exchange，提问作者Wizard