为什么以上工作？
char*p = new char[4];
p = "hey";
p = "jey";
但这不是吗？
char* p = new char[4];
p = "hey";
p[0] = 'j';
第二个示例导致分段错误.
在第一个例子中,"jey"是否覆盖"hey"？
这有效:
void foo(int (&a)[3]) {
auto ibegin = begin(a);
auto ebegin = end(a);
}
虽然这不是:
void foo(int (*a)[3]) {
auto ibegin = begin(a);
auto ebegin = end(a);
}
我考虑int (&a)[3]并int (*a)[3]具有相同的含义!
在第 3 步中上传照片的元数据时，在谷歌街景中出现错误：
{
"error": {
"status": "INVALID_ARGUMENT",
"message": "The API Key and the authentication credential are from different projects.",
"code": 400,
"details": [
{
"@type": "type.googleapis.com/google.rpc.Help",
"links": [
{
"url": "https://console.developers.google.com/project/3624944027/apiui/credential",
"description": "Google developer console API key"
}
]
}
]
}
}
我想创建一个std::vector<float> vpd将引用的float*.
float * old = new float[6];
for (int i = 0; i < 6; i++)
{
old[i] = i;
}
vector<float> vpd(6);
auto refasd = &*vpd.begin();
*refasd = *old;
vpd[0] = 23;
cout << old[0] << endl;
我应该如何修改代码,如果我想要得到23的cout？
所以我和朋友争吵了,有什么比SO更好的解决方法呢？
以下面的简化示例为例.假设所有其他功能都正确实现.这个复制构造函数泄漏内存吗？
我的立场是,绝对不是.它[rhs._size]为新对象分配内存,当对象超出范围时在析构函数中释放,并且分配的内存rhs在其各自的析构函数中释放.
template<typename T>
class dynarray
{
private:
T* _data;
std::size_t _size;
public:
dynarray(const dynarray& rhs)
: _data(new T[rhs._size]), _size(rhs._size)
{
std::copy(rhs._data, rhs._data + rhs._size, _data);
}
~dynarray() { delete[] _data; }
};
#include <vector>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(int argc, const char *argv[])
{
vector<bool> a;
a.push_back(false);
int t=a[0];
printf("%d %d\n",a[0],t);
return 0;
}
此代码提供输出"5511088 1".我以为它会是"0 0".
有人知道为什么吗？
我有以下小的可变参数模板,它应该划分一系列数字.据我所知,这是一个粗略的草图,如果我打电话会发生什么divide(20, 2, 2)- > 20/ 2 / 2.显然它不会发生那么好,因为我得到的答案是20 ...当只有两个参数时,它工作正常.
#include <iostream>
template<class first_t>
auto divide(const first_t &first)
{
return first;
}
template<class first_t, class... rest_t>
double divide(const first_t &first, const rest_t&... rest)
{
return first / divide(rest...);
}
int main()
{
std::cout << divide(20, 2, 2); //should print 5
std::cin.get();
}
所以问题是,最新标准是否指定标准C++库中的函数何时被内联声明？
望着algorithm从铛,GCC和MSVC的实现,每一个功能,除非是在constexpr的那些头文件,内联声明.
我会继续询问何时内联和什么不是,但我不想有关于编译器如何知道更好或微优化的通常论点,所以我可能不应该让这句话留在问题中.等一下...
请考虑以下代码示例:
#include <iostream>
#include <tuple>
template<typename T, std::size_t Rank, std::size_t... In>
struct help;
template<typename T, std::size_t... In>
struct help<T, 1, In...>
{
static constexpr auto a = std::make_tuple(In...);
T data[std::get<0>(a)];
};
template<typename T, std::size_t... In>
struct help<T, 2, In...>
{
static constexpr auto a = std::make_tuple(In...);
T data[std::get<0>(a)][std::get<1>(a)];
};
template<typename T, std::size_t... In>
class foo : public help<T, sizeof...(In), In...>
{
private:
using base = help<T, sizeof...(In), In...>;
public:
template<typename... Tn>
constexpr foo(Tn&&... args)
: base{ { args... } } …