我们有一个大型 C++ 存储库，大小为 80 GB，包含近 200,000 个文件，包含多个组件。
库（档案）对于更多数量的紧密耦合的组件来说是常见的。
这样，所有 git 操作以及编译/构建特定组件都会花费太长时间。
请建议我如何将这个单个存储库划分为多个存储库。
我正在做一个只移动的等价物std::function.move_function包含指向基类的指针,move_function_base该类型会删除基础的仿函数类型.move_function_imp继承move_function_base并保存类型化的底层函子.move_function_imp定义如下:
template<class F, class ReturnType, class... ParamTypes>
class move_function_imp : public move_function_base<ReturnType, ParamTypes...> {
typename std::remove_reference<F>::type f_;
public:
virtual ReturnType callFunc(ParamTypes&&... p) override {
return f_(std::forward<ParamTypes>(p)...);
}
explicit move_function_imp(const F& f) : f_(f) {}
explicit move_function_imp(F&& f) : f_(std::move(f)) {}
move_function_imp() = delete;
move_function_imp(const move_function_imp&) = delete;
move_function_imp& operator=(const move_function_imp&) = delete;
};
当我使用它时,我得到一个错误,构造函数不能相互重载.我究竟做错了什么？完整代码位于此处.
编辑:从ideone链接粘贴的错误:
prog.cpp: In instantiation of ‘class move_function_imp<main()::__lambda0&, void>’:
prog.cpp:39:30: required from …当从非模板上下文引用函数模板时，该标准允许在封闭的命名空间范围声明之后或在翻译单元的末尾实例化函数模板：[temp.point]/1
对于函数模板特化、成员函数模板特化或类模板的成员函数或静态数据成员的特化，如果特化是隐式实例化的，因为它是从另一个模板特化和它所在的上下文中引用的引用取决于模板参数，特化的实例化点是封闭特化的实例化点。 否则，这种特化的实例化点紧跟在引用该特化的命名空间范围声明或定义之后。
函数模板、成员函数模板或类模板的成员函数或静态数据成员的特化可能在翻译单元内具有多个实例化点，并且除了上述实例化点之外，对于任何此类在翻译单元内有一个实例化点的特化，翻译单元的结尾也被认为是一个实例化点。类模板的特化在翻译单元内最多有一个实例化点。任何模板的特化都可能在多个翻译单元中具有实例化点。如果根据一个定义规则，两个不同的实例化点赋予模板特化不同的含义，则程序格式错误，无需诊断。
现在考虑这个最小的可重现示例：
#include <iostream>
#include <array>
struct A {};
std::array<char, 2> show(float, A)
{
std::cout << "2\n";
return {};
}
template<typename T>
struct Fun {
decltype(show(0, T{})) b;
};
template <typename T>
void func(T, int c = sizeof(Fun<T>{}.b))
{
show(0, T{});
std::cout << c << '\n';
}
int main()
{
func(A{});
}
char show(int, A)
{
std::cout << "1\n";
return {};
}
GCC 和 Clang 输出1 2（Godbolt）。
在这里，func<A> …
当我写作
T min(T& a,T& b)
{return a<b?a:b;}
并且调用min(3,4),它将产生错误.
如何实现通用min？
int a,b,c,d=0;
cin>>a>>b>>c;
for (int i=a;i<=b;i++)
{
if (i%c==0){d++;}
}
cout<<d;
所以这是代码,a..b是数字范围,c是除数,并d计算的倍数c.例如,当a=5, b=15, c=3,d等于4,因为"6,9,12,15"是5和15,我需要找到更快的方法来做到这一点的倍数,谁能帮助？
我对boost :: ref的使用感到困惑.我不明白为什么任何人想要做以下事情 -
void f(int x)
{
cout << x<<endl;
x++;
}
int main(int argc, char *argv[])
{
int aaa=2;
f(boost::ref(aaa));
cout << aaa<<endl;
exit(0);
}
将ref传递给函数有什么用？我总是可以通过价值来代替.也不是说裁判实际上是通过了.在上面,主要的aaa值仅为2.
boost ref究竟在哪里有用？
在这种情况下是否可以使用boost :: ref.我想传递iterator引用std :: sort函数.通常这个排序适用于迭代器副本 - boost :: ref是否也适用于引用？(对std :: sort没有任何更改)
我基本上寻找一种将数组的大小/长度传递给函数的"动态"方式.
我试过了:
void printArray(int arrayName[])
{
for(int i = 0 ; i < sizeof(arrayName); ++i)
{
cout << arrayName[i] << ' ';
}
}
但我意识到它只考虑它的字节大小而不是数组上有多少元素.
并且:
void printArray(int *arrayName)
{
while (*arrayName)
{
cout << *arrayName << ' ';
*arrayName++;
}
}
这至少打印了我所有的东西,但超出了我的预期,所以它实际上并不像我想要的那样.我认为这是因为我并没有确切地告诉它我需要它有多大所以它"安全"并且给我一些大的尺寸并最终在我的阵列中的最后一个元素之后开始打印非常奇怪的整数.
所以我终于完成了这项工作,但我相信那里有更好的东西!:
void printArray(int *arrayName)
{
while (*arrayName)
{
if (*arrayName == -858993460)
{
break;
}
cout << *arrayName << ' ';
*arrayName++;
}
cout << '\n';
}
运行程序几次之后,我意识到我输入的数组的最后一个元素之后的值总是:-858993460,所以一旦遇到这个值,我就把它打破了while循环.
include <iostream>
include <conio.h>
using namespace std;
// functions …#include <stdio.h>
int* func()
{
static int a = 5; /* line 5 */
printf("%d\n",++a);
return &a; /* line 7 */
}
int main(void)
{
int *b = func(); /* line 12 */
(*b)++;
func();
}
这是编码作业的测试代码示例,因此不一定是最佳的.我有基本的c ++和Java知识,但是这些是C中的指针,我遇到了麻烦.
func()的返回类型是指针,但它返回整数的地址(第7行).整数是静态的(第5行)是否必须对此做任何事情？
第12行实际上做了什么？
此代码的输出是:
6
8
分析一些代码:
static volatile UCHAR *pucSndBufferCur;
eMBErrorCode eMBRTUSend( UCHAR ucSlaveAddress, const UCHAR * pucFrame, USHORT usLength )
{
if( eRcvState == STATE_RX_IDLE )
{
/* First byte before the Modbus-PDU is the slave address. */
pucSndBufferCur = ( UCHAR * ) pucFrame - 1;
/* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */
pucSndBufferCur[0] = ucSlaveAddress;
看起来不安全,如果地址中的内存(pucFrame - 1)已用于其他变量并覆盖它可能会导致故障.
您怎么看？这样的代码可以使用还是错误的方式,永远不应该使用？
我有一些代码根据参数的类型使用 _Generic 来调度函数。我不明白 gcc 生成的警告。
\n编译用gcc main.c
#include <stdio.h>\n\n#define FOOBAR(x) _Generic((x), \\\n int *: foo(x), \\\n long *: bar(x) \\\n)\n\nvoid foo(int* x) {\n printf("foo\\n");\n}\n\nvoid bar(long* y) {\n printf("bar\\n");\n}\n\nint main() {\n int a = 1111;\n long b = 2222;\n\n FOOBAR(&a);\n FOOBAR(&b);\n}\n现在，这段代码确实可以编译，并且 _Generic 按预期工作，即“foo”出现，然后“bar”出现。然而，编译器（gcc 和 clang）生成一个奇怪的警告，看起来它会将 _Generic 的参数匹配到错误的行：
\nmain.c: In function \xe2\x80\x98main\xe2\x80\x99:\nmain.c:20:12: warning: passing argument 1 of \xe2\x80\x98bar\xe2\x80\x99 from incompatible pointer type [-Wincompatible-pointer-types]\n 20 | FOOBAR(&a);\n | ^~\n | |\n | int *\nmain.c:5:15: note: in definition …