将随机生成器与分布通用封装为类模板的移植与实现问题

Hey Francis, let’s break down the common pain points you’re hitting here—porting legacy C++ random number classes from VS2008/2010 to VS2017, then running into issues with generic functions using those modified classes is super common. Let’s walk through the most likely culprits and fixes:

First, the changes you made to get your old classes compiling in VS2017 might have introduced subtle issues that only show up when using generics. Here’s what to check:

• Stricter C++ Standard Compliance: VS2017 enforces C++11/14 rules way more strictly than the old VS versions. Your original code might have relied on non-standard extensions (like skipping template angle brackets for std::vector, or implicit pointer conversions) that are now rejected. For example, if your old code had RNG my_rng instead of RNG<MySeedType> my_rng, VS2017 will throw an error immediately.
• Name Lookup Changes: Modern C++ has tighter argument-dependent lookup (ADL) rules. If your random classes use custom operators or helper functions, VS2017 might not find them where VS2008 did. Make sure any helpers are in the same namespace as your classes, or explicitly qualify their names.
• Standard Library Shifts: The <random> library got major updates in C++11. If your original code wrapped or interacted with old std random utilities (like std::rand() or outdated engine types), there could be breaking changes—renamed types, removed methods, or altered behavior that clashes with your modified classes.

Once your classes compile on their own, here’s why generics might still fail:

• Missing Required Interface Members: Generic functions often assume your classes have specific typedefs or methods (like result_type for the output type, or operator()() to generate a number). If your modified classes don’t explicitly define these, the compiler will throw errors. For example:

  template <typename RNG>
  auto get_random(RNG& rng) -> typename RNG::result_type {
      return rng(); // Fails if RNG lacks result_type or operator()
  }
  

  Fix: Align your classes with the standard <random> interface—explicitly declare result_type, min(), max(), and a properly qualified operator(). This not only fixes generic issues but makes your code interoperable with standard algorithms too.
• Template Deduction Failures: VS2017’s template deduction is stricter than VS2008’s. If your generic function relies on implicit conversions (like passing a generator pointer instead of a reference), deduction will fail. For example, if your distribution class expects an RNG& but you pass &my_rng to the generic function, the compiler can’t match the types.
  Fix: Use forwarding references (template <typename T> void func(T&& t)) to preserve argument categories, or explicitly cast arguments to the expected type.
• Const-Correctness Gaps: Older VS versions let you get away with const violations in templates. If your generator’s operator() isn’t marked const (but it should be, since generating a number doesn’t always modify state), a generic function that takes a const RNG& will fail to call it.
  Fix: Audit your class’s methods—mark operator() as const if it doesn’t change internal state, or adjust your generic function to take a non-const reference if state modification is necessary.
• Explicit Instantiation Woes: If you’re explicitly instantiating generic functions for your classes, VS2017 might require more explicit template arguments than VS2008. For nested templates, you’ll need to spell out every parameter explicitly instead of relying on deduction.

• Crank Up Compiler Warnings: In VS2017, go to Project Properties > C/C++ > General, set Warning Level to /W4 and enable /permissive- (strict mode). This gives you detailed error messages that point exactly to the problem—like a missing typedef or const violation.
• Test Minimal Examples: Create a stripped-down program that only includes your random class and the problematic generic function. Removing unrelated code will make it way easier to see if the issue is in the class, the function, or their interaction.
• Mirror Standard Library Patterns: Take a look at how std::mt19937 and std::uniform_int_distribution are structured. Copying their interface will save you from reinventing the wheel and ensure compatibility with generic code.

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