也许这是一个 XY 问题，尽管我个人不这么认为……
我们有一个平面无向图。本质上，将多边形分割成多个部分（这是 X :)）。任务是找到简单的（基本的，或者任何不包括其他的循环）循环（阅读 - 这些区域被划分成的区域。
例如，这是一个图表：
处理后，我需要类似向量的向量 - {2,6,11,10}，{6,11,5,7} 等。
我发现了一个类似的问题，但我不明白如何从那里获得我需要的东西。
初始问题：平面上有N个点，在这些点上有N个顶点的所有星形多边形中，找到面积最小的一个。这些区域是可能的星形多边形的核心。如果我找到了它们，那么将它们全部构建并找到合适的将是一项非常简单的任务。该图显示了点集 {1,2,3,4,5} 的内核。
几天前，需要以编程方式确定一艘飞船的机器正常运行时间。嗯，问题很简单（GetTickCount[64]），但结果却很奇怪：虽然我早上打开了车，但很自信地得出正常运行时间超过一天的结论，表明昨天早上。我查看了任务管理器窗口中的相同值。
重新启动 - 一切正常，数据正确。但他开始追随。
连续几天，它都显示正常，在所有机器关闭的情况下都能正常工作。
昨晚，像往常一样，我通过“关机”关闭了机器。今天早上她告诉我——我从昨天早上就开始工作了！
会是什么呢？某种我没有要求的冬眠？我怎样才能确定？
这种情况是怎么发生的，我不知道。总的来说，我工作了，在本地做了一些提交，一切都很好。我决定将其发送到服务器，
> git push origin
fatal: You are not currently on a branch.
To push the history leading to the current (detached HEAD)
state now, use
git push origin HEAD:<name-of-remote-branch>
它是什么<name-of-remote-branch>——只有 git 知道......
我看一下状态：
> git status
HEAD detached from origin/master
Untracked files:
(use "git add <file>..." to include in what will be committed)
VCRelease64/
nothing added to commit but untracked files present (use "git add" to track)
好吧，未跟踪的文件我根本不感兴趣。
我在互联网上搜索 - 建议是“do git checkout origin/master”。很好的是，我完全保存了所有内容，以防万一 - 我扔掉了最后两次提交，然后……好吧，没有剩下的了。已恢复。
在 gitk 中，如图所示。
问：需要做什么才能恢复正常并且不丢失任何东西？作为一种选择，我已经在考虑 - 尝试再次从服务器中提取所有内容，作为一个新项目，将更改重写到其中并工作，但不知怎的，它不公平:)
我不确定有必要解释一下 git 是如何工作的——我还是完全不明白，无论我读了多少，如果当局没有要求，我也不会费心。所以这很简单——如何在这种情况下驾驶，用两个词解释为什么会这样（突然间我就明白了）。据我了解，我不需要将 HEAD 附加到某处，但我需要将 origin/master 附加到它，不是吗？
PS 总是git commit足够的git push:)
回答了继承过程中同名的问题。我编写了以下代码（见下文）。Visual C++ 编译它并运行它。但许多其他编译器发誓
d.C::A::x = 2;
d.B::A::x = 3;
和挑战out()，认为选择存在模糊性A::x。坦白说，我不这么认为；VC++ 的输出符合预期。
有人可以通过明确引用标准的条款来证明这个或那个编译器的正确性吗？B当明确指出通过or 的路径时，歧义从何而来C？如何在这样的编译器中消除它，谁不满意？
#include <iostream>
using namespace std;
struct A
{
int x;
void out() { cout << x << endl; }
};
struct B: public A
{
int x;
void out() { cout << x << endl; }
};
struct C: public A
{
int x;
void out() { cout << x << endl; }
};
struct D: public B, public C
{
int x;
void out() { cout << x << endl; }
};
int main()
{
D d;
d.C::x = 0;
d.B::x = 1;
d.C::A::x = 2; // неоднозначность в не-MSVC
d.B::A::x = 3; // неоднозначность в не-MSVC
d.B::A::out(); // неоднозначность в не-MSVC
d.C::A::out(); // неоднозначность в не-MSVC
d.B::out();
d.C::out();
}
我做了一个学生作业，抽出了一个旧课程来处理一次制作的多项式。我自己不喜欢床单，但事实证明很难缩小代码，对不起......一切都很好。
决定炫耀加概念，限制“数学”类型。已发布
template<typename T>
requires is_integral_v<T>||is_floating_point_v<T>
class Polynome
同样，一切正常……但如果您使用复数，则不会遵守这些限制。我决定不假思索地使用我需要的算术运算编写一个简单的限制条件。
template<typename T, typename V>
concept PolyAble = requires(T a, V b){ a + b; a * b; };
template<typename T>
requires PolyAble<T,T>
class Polynome
一切都会好起来的——如果你不写乘法。如果您编写它，那么一切都会立即飞向友好的操作员的实施
Polynome<std::common_type_t<U,V>> operator*(const Polynome<U>& a, const V& x)
Polynome<std::common_type_t<U,V>> operator*(const V& x, const Polynome<U>& a)
在这两种情况下，咒骂最终都到了无法计算的地步PolyAble<Polynome<double>,Polynome<double>>。
所以问题是：首先，我根本不明白为什么要使用这些类型，其次，如何正确指定（如果在这种情况下有必要的话）模板自由函数的要求——在我看来因为他们使用带有分隔符的主类，所以它会在那里工作。
这是整张纸。Visual C++ 2022 编译器，17.6.0。
template<typename T>
concept PolyAble = requires(T a, T b){ a+b; a*b; };
template<typename T>
//requires is_integral_v<T>||is_floating_point_v<T>
requires PolyAble<T>
class Polynome
{
public:
Polynome(size_t n = 0):a(n+1,0){}
Polynome(std::initializer_list<T> cfs)
{
a.insert(a.end(),rbegin(cfs),rend(cfs));
norm();
}
~Polynome() {}
Polynome(const Polynome<T>&) = default;
Polynome& operator=(const Polynome<T>&) = default;
Polynome(Polynome<T>&&) = default;
Polynome& operator=(Polynome<T>&&) = default;
size_t extent() { return a.size()-1; }
T operator[](size_t i) const { return (i >= a.size()) ? T(0) : a[i]; }
std::vector<T> coeffs() const { return a; }
template<typename U>
auto operator()(const U& x) -> std::common_type_t<U,T>
{
std::common_type_t<U,T> res = std::common_type_t<U,T>();
for(auto c = a.rbegin(); c != a.rend(); ++c)
{
res = res*x + *c;
}
return res;
}
template<typename U, typename V>
friend Polynome<std::common_type_t<U,V>> operator+(const Polynome<U>& a, const Polynome<V>& b);
template<typename U, typename V>
friend Polynome<std::common_type_t<U,V>> operator-(const Polynome<U>& a, const Polynome<V>& b);
template<typename U, typename V>
friend Polynome<std::common_type_t<U,V>> operator*(const Polynome<U>& a, const V& x);
template<typename U, typename V>
friend Polynome<std::common_type_t<U,V>> operator*(const V& x, const Polynome<U>& a);
template<typename U, typename V>
friend Polynome<std::common_type_t<U,V>> operator*(const Polynome<U>& p, const Polynome<V>& q);
template<typename U>
friend std::ostream& operator<<(std::ostream&,const Polynome<U>&);
private:
std::vector<T> a;
void norm() {
for(auto i = a.rbegin(); i != a.rend(); i = a.rbegin())
if (*i == T(0)) a.erase(i.base()-1); else break;
if (a.empty()) a.push_back(T{});
}
};
template<typename T>
std::ostream& operator<<(std::ostream&os,const Polynome<T>&p)
{
os << "(";
for(auto i = p.a.rbegin(); i != p.a.rend(); ) { os << *i; if (++i != p.a.rend()) os << ","; }
return os << ")";
}
template<typename U, typename V>
Polynome<std::common_type_t<U,V>> operator+(const Polynome<U>& a, const Polynome<V>& b)
{
size_t N = std::max(a.a.size(),b.a.size());
Polynome<std::common_type_t<U,V>> p(N-1);
for(size_t i = 0; i < N; ++i) p.a[i] = a[i] + b[i];
p.norm();
return p;
}
template<typename U, typename V>
Polynome<std::common_type_t<U,V>> operator-(const Polynome<U>& a, const Polynome<V>& b)
{
size_t N = std::max(a.a.size(),b.a.size());
Polynome<std::common_type_t<U,V>> p(N-1);
for(size_t i = 0; i < N; ++i) p.a[i] = a[i] - b[i];
for(auto i = p.a.rbegin(); i != p.a.rend(); i = p.a.rbegin())
if (*i == std::common_type_t<U,V>{}) p.a.erase(i.base()-1); else break;
p.norm();
return p;
}
template<typename U, typename V>
Polynome<std::common_type_t<U,V>> operator*(const Polynome<U>& a, const V& x)
{
Polynome<std::common_type_t<U,V>> p(a.a.size()-1);
for(size_t i = 0; i < a.a.size(); ++i) p.a[i] = a.a[i]*x;
p.norm();
return p;
}
template<typename U, typename V>
Polynome<std::common_type_t<U,V>> operator*(const V& x, const Polynome<U>& a)
{
return a*x;
}
template<typename U, typename V>
Polynome<std::common_type_t<U,V>> operator*(const Polynome<U>& p, const Polynome<V>& q)
{
Polynome<std::common_type_t<U,V>> r(p.a.size()+q.a.size()-2);
for(size_t i = 0; i < p.a.size(); ++i)
for(size_t j = 0; j < q.a.size(); ++j) r.a[i+j] += p[i]*q[j];
r.norm();
return r;
}
using Poly = Polynome<double>;
int main(int argc, char * argv[])
{
double x[5] = {3,4,5,6,7};
double y[5];
Poly org{1.,2.,3.,0.,0.,0.,-3.};
for(int i = 0; i < 5; ++i) y[i] = org(x[i]);
vector<Poly> L(5,Poly{1});
for(int i = 0; i < 5; ++i)
{
for(int j = 0; j < 5; ++j)
if (i != j)
L[i] = L[i]*Poly{1,-x[j]}*(1.0/(x[i]-x[j]));
cout << i << ": " << L[i] << endl;
}
}
我还需要扮演请愿人的角色……我需要帮助在 LINQ 中编写查询。
逐字：
使用 LINQ to Object 查找每个机场自 2020 年 1 月 1 日起作为出发机场 (FromAirportId) 的航班数量。至 2020 年 12 月 31 日 （具有数据 AirportId、AirportNam、FlightCount 的对象列表）。按出发次数排序。第 48 行应该输入什么代码片段？
代码在这里：
namespace Application
{
public class Airport // аеропорт
{
public int AirportId { get; set; }
public string AirportName { get; set; }
}
public class Airplane //літак
{
public int AirplaneId { get; set; }
public DateTime DateAirplane { get; set; } //дата виробництва
}
public class Flight //рейс
{
public int FlightId { get; set; }
public int AirplaneId { get; set; }
public int FromAirportId { get; set; } //аеропорт вильоту
public int ToAirportId { get; set; } //аеропорт призначеня
public DateTime FlightDate { get; set; } //lдата рейсу
public int Passengers { get; set; } //кількість пасажирів
}
class Program
{
static void Main(string[] args)
{
var airports = new List<Airport>(){
new Airport {AirportId = 1, AirportName = "Бориспіль"},
new Airport {AirportId = 2, AirportName = "Charles de Gaulle"},
new Airport {AirportId = 3, AirportName = "Schiphol"},
new Airport {AirportId = 4, AirportName = "El Prat"}
};
var airplanes = new List<Airplane>(){
new Airplane {AirplaneId = 10, DateAirplane = new DateTime(2000, 5, 25)},
new Airplane {AirplaneId = 20, DateAirplane = new DateTime(2002, 10, 25)},
new Airplane {AirplaneId = 30, DateAirplane = new DateTime(1989, 12, 30)}
};
var flights = new List<Flight>(){
new Flight {FlightId = 100, AirplaneId = 10, FromAirportId = 1, ToAirportId = 2, FlightDate = new DateTime(2020, 5, 25), Passengers = 150},
new Flight {FlightId = 200, AirplaneId = 10, FromAirportId = 1, ToAirportId = 3, FlightDate = new DateTime(2020, 6, 25), Passengers = 100},
new Flight {FlightId = 300, AirplaneId = 10, FromAirportId = 2, ToAirportId = 1, FlightDate = new DateTime(2020, 5, 26), Passengers = 95},
new Flight {FlightId = 400, AirplaneId = 20, FromAirportId = 1, ToAirportId = 3, FlightDate = new DateTime(2020, 8, 26), Passengers = 155},
new Flight {FlightId = 500, AirplaneId = 20, FromAirportId = 3, ToAirportId = 1, FlightDate = new DateTime(2020, 8, 27), Passengers = 132}
};
var query = ???????????????
foreach (var x in query)
{
Console.WriteLine(x.AirportId + " " + x.AirportName + " " + x.FlightCount);
}
}
}
}
第 48 行充满了问号。
到目前为止，结果是——通过一个地方（lambda 函数），这已经是 C 级了。但是我不明白如何获得机场的名称。在SQL中，你可以从几个表中收集查询，但是这里好像不行？
同时，您根本无法添加没有航班的机场... :(
var query = from a in airports
join g in flights on a.AirportId equals g.FromAirportId
where g.FlightDate.Year == 2020
group g by g.FromAirportId into q
orderby q.Count(), q.Key
select new { AirportId = q.Key,
AirportName = airports.Find(x=>x.AirportId == q.Key).AirportName,
FlightCount = q.Count() };
大学里的小家伙得到了任务 - 编写一个编译程序，可以这么说，在该程序中应该尽可能多地使用相同的标识符。但只是不同，所以有些嵌套
namespace a { namespace a { namespace a {
与单个命名空间相比，它没有提供任何新的东西。
既然小号已经作曲发了
namespace a
{
struct a
{
int a;
};
int a()
{
struct a a {0};
return a.a;
}
}
int main()
{
int a = a::a();
std::cout << a;
}
我认为自己有权将这个问题作为一个问题提出——谁能取得更多成就？:)
受到另一个问题的启发，试图回答这个问题，我发现 VC ++ 2019 的这种行为对我来说是难以理解的。
编码：
#include <iostream>
using namespace std;
class String
{
public:
String(char* str):p(str){};
const char& operator[](size_t i) const { return p[i]; }
char& operator[](size_t i) { return p[i]; }
operator const char* () const { return p; }
operator char* () { return p; }
private:
char* p;
};
int main() {
char s[] = "123456";
String name = s;
std::cout << name[0] << std::endl;
name[1] = '5';
std::cout << name << std::endl;
}
不要查看内存和其他类似问题的各种可能问题，这只是将代码削减到最低限度。
因此，当将 x64 编译为 string 时cl /EHsc main.cpp，一切都会顺利进行。
但是对于 x86 使用相同的命令，我们得到
main.cpp
main.cpp(20): error C2666: String::operator []: для перегрузок (4) есть подобные преобразования
main.cpp(10): note: может быть "char &String::operator [](size_t)"
main.cpp(9): note: или "const char &String::operator [](size_t) const"
main.cpp(20): note: или "встроенный оператор C++[(const char *, int)"
main.cpp(20): note: или "встроенный оператор C++[(char *, int)"
main.cpp(20): note: при попытке сопоставить список аргументов "(String, int)"
main.cpp(21): error C2666: String::operator []: для перегрузок (4) есть подобные преобразования
main.cpp(10): note: может быть "char &String::operator [](size_t)"
main.cpp(9): note: или "const char &String::operator [](size_t) const"
main.cpp(21): note: или "встроенный оператор C++[(const char *, int)"
main.cpp(21): note: или "встроенный оператор C++[(char *, int)"
main.cpp(21): note: при попытке сопоставить список аргументов "(String, int)"
有人可以解释为什么在为不同平台编译时会有这样的差异吗？...
PS G++：https ://ideone.com/TbDfC2
实际上，一切都在标题中说明。
人们经常认为这种方法不好，特别是对于小值N。但我想了解它有多糟糕？
是否可以使用它还是绝对不能接受？
受到这个问题的启发。
我的决定
#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
#include <iomanip>
using namespace std;
int main(int argc, char * argv[])
{
vector<int> v(36000000);
int k = 0;
for(int i = 1; i <= 6000; ++i)
for(int j = 6001; j <= 12000; ++j)
v[k++] = i*j;
sort(v.begin(),v.end());
long long s = 0;
for(int i = 0; i < 36000000; ++i) s += v[i];
cout << s;
}
工作原理与 Python 中最好的差不多，但速度稍慢。在我的机器上，这一切都计为大约 2.04±0.01 秒。好吧，这不可能是 C ++ 不如 Python :) - 我开始尝试以各种方式加速这段代码。
无法优化，一切都依赖于sort. 带着悲伤，我把它换成了stable_sort——看看会发生什么，然后——你瞧！— 时间下降到 1.30±0.03 秒。
似乎一直有人说，在一般情况下，由于更大的复杂性stable_sort（不仅是算法，它等于O(N·log(N) 2）），它的效果更差sort。但是，事实证明，至少并非总是如此？我知道常数可能会有很大的不同:)，但是它什么时候小于常数sort？
在 G++ 下进行了检查-差异略有不同，但通常相同：1和2。
没有人对此进行深入研究，无法发表评论，如果两种功能都适合您，什么时候应用更有效？
视觉 C++ 2019，Windows 10
两个键盘有时是不够的 - 例如，在当地杂志上写什么文章 - 现在，根据法律，只有乌克兰语......对于普通生活，95％的时间，两种布局就足够了 - 英语/俄语。每次你记得你需要切换到 Alt-Shift 不是一次，而是两次 - 你的头开始受伤。
您可以通过语言栏添加和删除键盘，但坦率地说，这是痔疮。
所以问题是：我将如何配置（或写一些东西，或下载一些东西）Windows（10）以便一键添加键盘？
是的，我知道您可以简单地为每种语言设置自己的键盘快捷键，但这也是关于重新学习和发展新的反应能力:) 我也同意乌克兰语的单独组合，但让 Alt-Shift 跳过它。
PS 是的，Windows 更新到 2004 后，在切换语言时，屏幕右侧开始跳出带有该语言的窗口。什么设置没有删除- 不想。烦人的侵入式服务，如何去除？...
真的很不舒服，但是...
小家伙被布置了作业——用 e-olymp 选择和解决 DP 中的任何问题。他选择了这个（下面的文字）。一小时后来找我——怎么了？为什么只有 22% 通过？
任务看起来很简单，但我显然没有看到任何东西，因为就我而言，他的代码中没有错误（好吧，除了非最优性）。戳我们 - 我们没有直接看到什么？ ...
健康）状况：
许多具有 2D 图形的旧游戏可能会遇到类似情况。什么房地产英雄跳上悬在空中的平台（或岛屿）。它必须从屏幕的一个边缘移动到另一个边缘。同时，从一个平台跳到另一个平台时，英雄拿|y 2 -y 1 | 2能量，其中 y 2和 y 1是这些平台所在的高度。此外，英雄还有一个超级招式，可以让你跳过平台，但需要花费3·|y 2 -y 1 | 2个能量单位。当然，能源应尽可能经济地使用。
假设您按从左到右的顺序知道所有平台的坐标。你能找到英雄从第一个平台到最后一个平台所需的最小能量吗？
输入数据
第一行包含平台数量 n (2 ≤ n ≤ 100000)。第二行包含 n 个不超过 4000 的自然数——平台所在的高度。
输出
打印一个数字 - 玩家克服平台必须花费的最小能量。
这是他的解决方案：
#include <iostream>
using namespace std;
long long int m[100001];
long long int h[100001];
long long int sq(long long int n) { return n*n; }
long long int min(long long int x, long long int y) { return (x < y) ? x : y; }
int main()
{
int n;
cin >> n;
for(int i = 1; i <= n; ++i)
{
cin >> h[i];
}
m[1] = 0;
m[2] = sq(h[2]-h[1]);
for(int i = 3; i <= n; ++i)
{
m[i] = min(sq(h[i]-h[i-1]) + m[i-1],
3*sq(h[i]-h[i-2]) + m[i-2]);
}
cout << m[n] << endl;
}
好吧，一切都很简单——在第一个平台上，能量为 0，在第二个平台上——只是一个正方形（你只能从第一个平台上得到），然后——我们看看普通跳跃和超级跳跃的成本并取最小的......眼睛有long long int足够的范围。
受到这个答案的启发。突然间我意识到我知道如何衡量一个程序的性能，但是如何确定它需要多少内存——这是我在教育方面的差距:)
拦截new和delete？令人怀疑的是，不难相信一切都只能通过这些运营商运作。
总之，没有人会告诉你如何以最好、最可靠、最准确的方式来做，最好不是从外部，而是从程序本身？
更具体地说 - Windows，使用 Visual C++ 2017。
受到这个问题的启发。
因此，有一些模板类，我们想向其传递未知数量的参数，但类型相同。
最简单的解决方案是通过参数化的initializer_list.
但是我们不是在寻找简单的方法 :) 并且我们希望使用具有可变数量参数的模板，但所有参数的类型都单一。并且有这个限制。
如何表达这样的限制？没关系 - 在 C++17 或 C++20 中（我在暗示概念）。
我正在阅读 Stroustrup 的“A Tour of C++”，在第 77 页我遇到了这个建议：
如果一个类有一个指针成员，它可能需要一个用户定义或删除的析构函数，复制和移动。
那些。这好像是
如果一个类有一个指针成员，它可能需要一个自定义或远程析构函数、复制和移动。
关于复制和移动 - 毫无疑问，一切都很清楚，关于自定义析构函数 - 也是。
但是远程析构函数是什么意思呢？不打算写
~Class() = delete;
它能给什么？毕竟，这样的对象既不能在离开范围时自动删除，也不能通过delete（new分别是明确的、本地的和选择的）删除。
这里的深层含义是什么——创造不朽的对象？:)
PS 写信给 Stroustrup，要求解释 :) 他同意措辞不是最准确的，提出了一个变体
如果一个类有指针成员，考虑是否需要用户定义或删除的析构函数，复制和移动；
至于我，差异很小，但是......在这方面，@lёxölüt 的答案更接近现实，因此我接受它。
由于没有人能够回答有关FTE的问题……
我不喜欢 Visual C++ 项目中过多的默认设置。我决定为自己制作一个标准空白 - 我创建了一个项目，仔细设置了属性，创建了一个源代码，其中包含项目中的模板文本。保存为模板。一切都在那里，一切都打开了，项目正在创建中。
只有我的带有源代码的存根文件丢失了。当你自己尝试添加到.zip中写为<ProjectItem>时，好像在项目中注明，但是当你尝试打开的时候，却报告说没有这个文件（而且创建的确实没有这个文件）目录）。
由于某种原因，这个问题在网上完全被忽略了（至少我找不到答案）。
告诉我我做错了什么？如何强制创建源（使用为项目选择的名称），并使其在编辑器窗口中自动打开？
输入一个数字（例如，年龄）后，我读取了一个字符串（例如，名字和姓氏），但结果我得到了一个额外的空行。它来自哪里以及如何摆脱它？
例如，
struct Person
{
char firstname[20];
char lastname[20];
int age;
};
Person p;
cin >> p.age;
cin.getline(p.firstname,20);
cin.getline(p.lastname,20);
之后，一个p.firstname空字符串出现在 中，并p.lastname输入了 for p.firstname。
尝试使用 C 函数时也是如此
scanf("%d",&p.age);
fgets(p.firstname,10,stdin);
fgets(p.lastname,10,stdin);
使用代码时
while(!feof(file))
{
// Чтение из файла
}
在 C 或
while(!file.eof())
{
// Чтение из файла
}
在 C++ 中你会遇到麻烦——例如，一个额外的读取行。为什么？如何正确检查是否已到达文件末尾？
从一个月内的某个时间点开始（我不能更准确地说），更新服务停止工作。任何尝试启动它，搜索更新都会遇到
Windows Update 当前无法搜索更新，因为此服务未运行。您可能需要重新启动计算机。
很明显，重载并没有给出任何东西。Windows 更新和后台智能传输服务正在运行。手动重新启动- 没有帮助。
似乎没有设置任何新内容，设置没有改变。
Windows 7 64 位。
在家里的另外两台机器上同样的废话 - 只是有 Windows 7 32 位。
我犯了某种更新 - 我试图拆除最新的 Windows 更新 - 它也没有帮助。更新 Office 或 Visual Studio 未删除。
Windows 更新疑难解答下载，启动。挖，说一切都是固定的 - 但什么都没有改变。
我们有 - 一个模板函数，也是递归的，其中很多东西是从不同的（头）文件中提取的，并且只有一个模板 - 将找到的值写入迭代器。像这样的东西
template<typename Itor>
void terribleFunction(Itor it, type1 param1, type2 param2, ...)
{
// Всякие дела
for(....
{
// И еще дела
// Первое использование it
if(...) terribleFunctiom(it,p1,p2,...);
// И еще...
// Второе использование it
if (...) *it++ = что-то;
// И еще...
}
}
或多或少是这样的。我想尽可能地隐藏所有代码 - 其中没有任何模板 - 无论是在库中还是在单独的文件中 - 通常，至少尽量不要在头文件中产生依赖关系，写出所有代码在里面，尽量把它去掉，变成一些辅助功能，不管。但无论我想出什么 - 都是通过一个不雅的地方......
在这里应用什么棘手的方法，提示？ ...