问题[c++](coding)

当重复声明具有默认参数的模板类时，出现错误：

<source>:12:23: error: redefinition of default argument for 'class<template-parameter-1-2>'
   12 | template <typename T, typename = T>
      |                       ^~~~~~~~
<source>:9:23: note: original definition appeared here
    9 | template <typename T, typename = T>
      |         

重复没有默认参数的模板前向声明不会产生任何错误。重复相同的操作，但不使用默认参数也可以（但在我看来这没有意义，应该会产生一些错误）。
以下是整个示例：

template <typename T>
struct ok;

template <typename T>
struct ok;

template <typename T, typename = T>
struct not_ok;

template <typename T, typename = T>
struct not_ok;

template <typename T, typename = T>
struct why_is_it_ok;

template <typename T, typename>
struct why_is_it_ok;

为什么？

我已经尝试std::enable_if过requires：

template <typename Ret>
struct promise_type {
  auto get_return_object() {/*...*/}
  auto initial_suspend() {/*...*/}

  auto return_void()
    -> std::enable_if_t<std::is_void_v<Ret>> {/*...*/}
  auto return_value(Ret)
    -> std::enable_if_t<!std::is_void_v<Ret>> {/*...*/}

  void unhandled_exception() {/*...*/}
  auto final_suspend() noexcept {/*...*/}

  // Rest of promise_type's definition ...
};

In file included from src/TestSyncTask.cpp:1:
In file included from include/asyncxx/SyncTask.hpp:2:
In file included from /usr/local/lib/gcc/x86_64-pc-linux-gnu/15.0.1/../../../../include/c++/15.0.1/coroutine:48:
/usr/local/lib/gcc/x86_64-pc-linux-gnu/15.0.1/../../../../include/c++/15.0.1/type_traits:2837:44: error: no type named 'type' in 'std::enable_if<false>'; 'enable_if' cannot be used to disable this declaration
 2837 |     using enable_if_t = typename enable_if<_Cond, _Tp>::type;
      |                                            ^~~~~
include/asyncxx/SyncTask.hpp:12:36: note: in instantiation of template type alias 'enable_if_t' requested here
   12 |         auto return_void() -> std::enable_if_t<std::is_void_v<Ret>> {}
      |                                    ^
src/TestSyncTask.cpp:4:15: note: in instantiation of member class 'SyncTask<int>::promise_type' requested here
    4 | SyncTask<int> async_main(const int argc, const char *const argv[]) {
      |               ^
1 error generated.

template <typename Ret>
struct promise_type {
  auto get_return_object() {/*...*/}
  auto initial_suspend() {/*...*/}

  auto return_void() requires std::is_void_v<Ret> {/*...*/}
  auto return_value(Ret) requires (!std::is_void_v<Ret>) {/*...*/}

  void unhandled_exception() {/*...*/}
  auto final_suspend() noexcept {/*...*/}

  // Rest of promise_type's definition ...
};

src/TestSyncTask.cpp:4:15: error: the coroutine promise type 'promise_type' declares both 'return_value' and 'return_void'
    4 | SyncTask<int> async_main(const int argc, const char *const argv[]) {
      |               ^
include/asyncxx/SyncTask.hpp:12:14: note: member 'return_void' first declared here
   12 |         auto return_void() requires std::is_void_v<Ret> {}
      |              ^
include/asyncxx/SyncTask.hpp:13:14: note: member 'return_value' first declared here
   13 |         auto return_value(Ret val) requires (!std::is_void_v<Ret>) {
      |              ^
1 error generated.

我该如何修复此问题？

我有一段 C++17 的 SFINAE 代码

#include <type_traits>

template<typename>
constexpr bool dependentFalse = false;

template<typename T>
struct IAmEmpty
{
    template<typename U=T, std::enable_if_t<dependentFalse<U>>* =nullptr>
    auto deleteMe()
    {}

};

template struct IAmEmpty<int>;

https://godbolt.org/z/vWW3favWj

我正在尝试将其重新编写为 C++20，我想知道：

#include <type_traits>

template<typename T>
struct IAmEmpty
{
    template<typename U=T>
    requires false
    void deleteMe() {}

    void deleteMeToo() requires false {}
};

template struct IAmEmpty<int>;

据我所知，领先的要求接近使用例如等实现的 C++20 之前的 SFINAE enable_if。void_t因此deleteMe实际上是一个成员函数模板。 deleteMeToo不是函数模板（或者我错了？）。实例： https://godbolt.org/z/rGzx8dz3f

是否存在deleteMe和deleteMeToo实际上表现不同的情况，并且在优先选择尾随要求而不是前导要求时应该注意？

我有以下课程：

template<typename Population, typename... Operators> class GA
{
public:
    template<typename Evaluator,
             typename std::enable_if_t<
             std::is_same_v<Evaluator, Evaluator<Operators...>>>>
  void EvaluatePopulation(Evaluator& evaluator)
  {
    evaluator.Evaluate();
  }
};

由于EvaluatePopulation声明不正确，因此无法编译。

我如何指定EvaluatePopulation只能使用与该类Evaluator相同的初始化类来调用方法？Operators...GA

我正在努力理解模板定义。我的基本理解是模板定义允许将数据类型作为返回或参数作为通用类型。也就是说，模板参数是编译器在编译时实例化和链接的数据类型，

但我无法理解如下的复杂定义：

#include <iostream>
#include <type_traits>

template <unsigned n>
struct factorial : std::integral_constant<int,n * factorial<n-1>::value> {};

template <>
struct factorial<0> : std::integral_constant<int,1> {};

int main() {
  std::cout << factorial<5>::value;  // constexpr (no calculations on runtime)
  return 0;
}

在哪里

template <class T, T v>
struct integral_constant {
  static constexpr T value = v;
  typedef T value_type;
  typedef integral_constant<T,v> type;
  constexpr operator T() { return v; }
};

输出：

120

很难想象模板是如何被实例化的：

template <int,5 * factorial<5-1>::value>
struct integral_constant {
  static constexpr int value = 5 * factorial<5-1>::value;
  typedef int value_type;
  typedef integral_constant<5 * factorial<5-1>::value> type;
  constexpr operator int() { return 5 * factorial<5-1>::value; }
};

我的项目用例如下：

• 带有几个声明的外部函数的 C 头文件
• 定义了这些函数的 C++ 源文件
• 将 C++ 源代码编译为共享库
• 在 C 源文件中，通过链接 .so 使用 C 头文件中声明的函数

我在做这件事时发现了一些奇怪的事情。事情开始与未命名的命名空间一起工作。

这是我的示例文件：

c_sample.h：

#include "stddef.h"

extern void hello(void);
extern void bye(void);

cpp_sample.cc：

#include <iostream>
#include "c_sample.h"

extern "C" {
    void hello(void) { std::cout << "HI" << std::endl; }
    void bye(void) { std::cout << "BYE" << std::endl; }
}

在尝试构建共享库时，我看到了预期的错误，因为c_sample.h 它包含在extern "C"块之外。

g++ cpp_sample.cc -shared -o libcppsample.so     
cpp_sample.cc:5:7: error: declaration of 'hello' has a different language linkage
    5 |         void hello() { std::cout << "HI" << std::endl;}
      |              ^
./c_sample.h:3:13: note: previous declaration is here
    3 | extern void hello();
      |             ^
cpp_sample.cc:6:7: error: declaration of 'bye' has a different language linkage
    6 |         void bye() { std::cout << "BYE" << std::endl;}
      |              ^
./c_sample.h:4:13: note: previous declaration is here
    4 | extern void bye();
      |             ^
2 errors generated.

然而，当我把它包装在一个未命名的命名空间中时，奇迹发生了

cpp_sample.cc：

#include <iostream>
#include "c_sample.h"

extern "C" {
namespace {
    void hello(void) { std::cout << "HI" << std::endl; }
    void bye(void) { std::cout << "BYE" << std::endl; }
}
}

编译成功了。当我尝试从另一个 C 源文件中使用它时，它甚至可以工作。

#include "stdio.h"
#include "c_sample.h"

int main() {
    hello();
}

$ gcc another.c -L/tmp -lcppsample -o another
$ ./another
HI

仅将其包装在命名空间内如何工作？它如何将声明的函数与其定义链接起来？

#include <iostream>
#include <vector>

class Car{
  public:
    int weight;

    Car(int weight): weight(weight){
      
    };

    Car(const Car& other){
        std::cout<<"copied!"<<std::endl;
        this->weight=other.weight;
    }
};

int main() {
    std::vector<Car> vec;
    vec.push_back(Car(1));
    return 0;
}

在上面的代码中，当我将 Car(1) 推送到 vec 上时，不知何故 Car 类中的复制构造函数被调用。为什么要调用复制构造函数？我这里没有复制任何东西。

我在使用 C++Builder 12 社区版构建的 C++ 控制台程序中的参数方面遇到了问题。

如果可执行文件位于名称中带有空格的文件夹中，例如"test dir"，并且我从另一个文件夹中的控制台会话调用它，则我的代码提取的参数不正确。如果可执行文件路径没有空格，则一切正常。如果我在 IDE 中运行它，它也可以正常工作。在 Visual Studio 22 下构建的代码也可以正常工作。

CPP测试.cpp

#include <iostream.h>

int main(int argc, char* argv[])
{
    cout << "argc: " << argc << "\n"; 
    cout << "argv0: " << argv[0] << "\n"; 
    cout << "argv1: " << argv[1] ; 
    return 0 ;`
}

可执行文件位于名为的目录中"Misc projects"，CWD 是"C:\Junk"：

C:\Junk>C:\"Misc projects"\CPPtest 3 8
argc: 2 ## INCORRECT: Should be 3
argv0: c:\Misc projects\CPPtest.exe
argv1: projects\CPPtest 3 8 # INCORRECT should be 8

在 Visual Studio 22 中运行时，相同的代码可以正确运行。

我很难理解导致此测试偶尔死锁的实际顺序。抱歉，示例有点长，很难可靠地重现我的问题。

理想情况下， inc_thread增量data然后设置flag并通知dec_thread。

dec_thread等待flag设置且data非零，然后减少data并清除flag。

REP_COUNT对每个线程重复此操作次，并以data结尾0。

如果flag.store(false, mem_order);使用std::memory_order_acq_rel这个，偶尔会出现死锁，dec_thread等待的flag时间data不为零。为什么？

即使所有其他操作都是隐式seq_cst或显式的，也会发生这种情况acq_rel。

#include <atomic>
#include <thread>
#include <cstdint>

void race_test() {

  // always works
  //constexpr auto mem_order = std::memory_order_seq_cst;
    
  // occasionally deadlocks
  constexpr auto mem_order = std::memory_order_acq_rel;

    
  std::atomic<std::size_t> data = 0;
  std::atomic_bool flag = false;

  constexpr std::size_t REP_COUNT = 2000;

  std::thread dec_thread{[&] {
    for (std::size_t i = 0; i != REP_COUNT; ++i) {
      while (data.load() == 0) {
        flag.wait(false);
        flag.store(false, mem_order);
      }
      --data;
    }
  }};

  std::thread inc_thread{[&] {
    for (std::size_t i = 0; i != REP_COUNT; ++i) {
      ++data;
      flag.store(true);
      flag.notify_one();
    }
  }};

  inc_thread.join();
  dec_thread.join();
}

int main()
{
  for (std::size_t i = 0; i != 1000; ++i)
    race_test();
}

当改变mem_order一切memory_order_seq_cst似乎总能正常工作。

我所能想象的问题在于，它的flag.store(false, mem_order);顺序是在之后data.load()（并且flag.store(true);在中inc_thread），但难道不应该被阻止吗acq_rel？

据我了解，memory_order_seq_cst这只能防止与其他操作重新排序memory_order_seq_cst，但难道不应该让一切都memory_order_acq_rel解决这个问题吗？（事实并非如此）

假设更改flag.store(false)为seq_cst甚至足以使此问题正确解决，有人能解释一下原因吗？如果有人能为每个原子操作说明最“宽松”的顺序，同时仍保持无竞争，我将不胜感激。

谢谢。

我有一些代码简化如下：

#include <iostream>
#include <string>


enum En
{
    one,
    two,
    three
};

auto get_str(int n, En en)
{
    if (n > 0)
    {
        return std::to_string(n);
    }

    switch (en)
    {
        case one:
            return std::string("one");
        case two:
            return std::string("two");
        case three:
            return std::string("three");
    }
}

int main()
{
    auto str = get_str(3, two);
    std::cout << str << '\n';
}

参见编译器资源管理器。

当我使用 GCC 14.2 或 13.3.0（带有或不带有-Wall -Wextra）进行编译时，它会抱怨get_str功能： warning: control reaches end of non-void function [-Wreturn-type]。

Clang 15.0 及以上版本-Wall -Wextra不会发出任何警告。VS17.10 也会抱怨：warning C4715: 'get_str': not all control paths return a value。

是什么导致 Clang 不同意？绕过 s 的路径是什么return？