我只是学习C++而我正在使用Accelerated C++.
在向量示例中,编写器使用以下代码;
typedef vector<double>::size_type vec_sz;
vec_sz size = homework.size;
我知道typedef vector<double>::size_type vec_sz;是这样他不必写下一个命令vector<double>::size_type size = homework.size;,但我的问题是为什么他不是只是声明size为整数？
int size = homework.size;
这是因为我们正在使用向量吗？
如果是这样,这是否意味着向量迭代器返回的值不能存储在常规变量中？
class B {
public:
virtual void f(){
printf("B\n");
}
};
class D : public B {
public:
void f() {
printf("D\n");
}
};
int main(void)
{
B* d = new D();
d->f();
auto b = *d;
b.f();
}
因为d->f();,输出是D.这是正确的.但是b.f();,输出是B.这是正确的吗？
#include <iostream>
#include <string>
#include <array>
class C {
private:
std::string a;
std::string b;
std::string c;
public:
C(std::string a_, std::string b_, std::string c_) : a{a_},b{b_},c{c_} {}
~C(){};
C(const C&) =delete;
C(const C&&) =delete;
const C& operator=(const C&) =delete;
const C& operator=(const C&&) =delete;
};
std::array<C,2> array = {C("","",""),C("","","")};
int main()
{}
这将无法编译(带有NDK和clang的Android Studio)带有"调用已删除的c构造函数"错误.我知道我可以使用a std::vector和emplace_back()直接在容器内构造一个元素,但在我的代码中我只想使用固定大小的容器和不可复制/可移动的对象进行优化.我可能在这里缺少基本的,但是没有一种方法来初始化,std::array而不必先构建单个元素然后将它们复制到那里？
错误:从'int'到'int*'的转换无效
int *q = 8;
工作良好.
*q = 6;
为什么我不能直接一个int分配给这样一个int指针:int *q = 6; 我可以在下一行安全地分配它吗？
感谢valgrind中的一些分段错误和警告,我发现这段代码不正确,并且在for-range循环中有一些悬空引用.
#include<numeric>
#include<vector>
auto f(){
std::vector<std::vector<double>> v(10, std::vector<double>(3));
iota(v[5].begin(), v[5].end(), 0);
return v;
}
int main(){
for(auto e : f()[5])
std::cout << e << std::endl;
return 0;
}
它看起来好像begin并end从临时取出,并循环丢失.
当然,一种方法是做
auto r = f()[5];
for(auto e : r)
std::cout << e << std::endl;
但是,我想知道为什么for(auto e : f()[5])是一个错误,如果有更好的方法或某种方式设计f或甚至容器(std::vector)以避免这个陷阱.
随着迭代循环是比较明显的,为什么这个问题发生(begin和end来自不同的临时对象)
for(auto it = f()[5].begin(); it != f()[5].end(); ++it)
但是在for-range循环中,就像在第一个例子中一样,这个错误似乎很容易.
gcc 8和clang 7不接受以下代码,它们应该默认构造一个临时类型unsigned int:
unsigned int ui = unsigned int{};
clang 7报告错误,例如
<source>:6:22: error: expected primary-expression before 'unsigned'
Visual C++ 2015和2017接受此.
显然,这适用于诸如int或任何默认可构造类类型之类的类型.
这是正确的C++ 14代码(在这种情况下是clang和gcc的错误)？如果没有,为什么不呢？除了无符号类型之外的哪些类型会受到相同的限制？
我正在尝试使用可选参数创建模板化函数,但我无法理解编译失败的原因.这是我的测试(人为)代码:
#include <iostream>
#include <vector>
template <class UnaryPredicate>
int GetCountIf(std::vector<int> v, UnaryPredicate pred = [](auto) { return true; }) {
int count=0;
for (auto i: v) {
if (pred(i)) {
count++;
}
}
return count;
}
int main() {
auto v = std::vector<int>{0, 1, 2, 3, 4, 5};
std::cout << "NumOddElements=" << GetCountIf(v, [](auto val) { return (val % 2 == 1); }) << '\n';
// std::cout << "NumElements=" << GetCountIf(v) << '\n';
}
只有在我GetCountIf()使用两个参数调用时,代码才会编译.如果我尝试仅传递1个参数,编译将失败并显示以下错误:
main.cpp:18:34:错误:没有匹配函数来调用'GetCountIf'std
:: cout …
我有以下代码：
#include <iostream>
struct C {
int a;
int& get() { return a; }
};
struct D {
int a;
int get() { return a; }
};
template <typename T>
auto foo(T o) { // no sample code is complete without a foo
return o.get();
}
int main()
{
C c;
D d;
c.a = 2;
d.a = 42; // no sample code is complete without a 42
std::cout << "c=" << c.a << ", d=" << d.a << "\n"; …我遇到了一个奇怪的案例。
// this does not work, and reports:
// constexpr variable 'b' must be initialized by a constant expression
int main() {
const double a = 1.0;
constexpr double b = a;
std::cout << b << std::endl;
}
// this works...
int main() {
const int a = 1;
constexpr int b = a;
std::cout << b << std::endl;
}
有什么特别之处double所以它不能constexpr工作？
此代码可以工作，无需指定构造函数：
struct Foo
{
int a;
int b;
};
//...
int a1, b1;
Foo foo = {a1, b1};
如果我将 Foo 作为模板，它就不起作用。
template<typename T1, typename T2>
struct Foo
{
T1 a;
T2 b;
};
//...
int a1, b1;
Foo foo = {a1, b1};
它说推论失败/提供了 2 个参数，而预期有 1 个参数。如果我添加一个像这样的构造函数，Foo(T1, T2){}它就可以工作。我想，这种构造默认适用于结构。我错了什么？
编辑：我正在使用 Clang，它似乎不支持它。MSVC 和 GCC 都使用 c++20 编译器标志来编译它。