我有以下示例,我已经从中分解§14.7.3/6 [temp.expl.spec]了在主模板中定义类成员枚举,然后专门化它.以下内容不能在clang中编译:
template<class T>
struct A {
enum E : T;
};
template<class T>
enum A<T>::E : T { eT };
template<>
enum A<char>::E : char { echar }; // ill-formed, A<char>::E was instantiated
// when A<char> was instantiated
// error: explicit specialization of 'E' after instantiation
原因应该是在专门化之前实例化未编组成员枚举的定义.14.7.1 [temp.inst]/1:
类模板特化的隐式实例化导致隐式实例化未编组成员枚举和成员匿名联合的定义.
我试图理解为什么这是一个问题.是因为如果枚举已经有了定义,那么在专门化期间会导致重新定义错误吗？
我正在尝试在C++类中创建一个方法,可以在不创建类的实例的情况下调用该方法(如Java中的静态方法),但我一直遇到这个错误: error: expected unqualified-id before ‘.’ token
这是我正在尝试编译的.cpp文件:
using namespace std;
#include <iostream>
class Method {
public:
void printStuff(void) {
cout << "hahaha!";
}
};
int main(void){
Method.printStuff(); // this doesn't work as expected!
return 0;
}
今天我在一个catch块中发现了一个错误:
catch (const exception& e){
// do something
// throw e; <-- bug!
throw; // <-- right thing to do
}
基本上,如果我e 明确地重新抛出异常,我会得到一个新的std::exception重构,实际上该what()方法的消息是默认的std::string,而不是我的自定义构建的消息.
解释是什么？我认为这throw;只是一个简写throw ExceptionJustCaught;.
很久以前我看过一个非递归实现来从类型序列/值序列中获取最后一个值/类型.它有一个很好的属性,实例化的模板数量是序列包含的元素数量的独立(和常量).
实现很简单,如下所示
// a struct that eats anything and everything
struct eat { template<class T> eat(T&&) {} };
// generates V matching with U
template<class U, class V> struct match { using type = V; };
template<class... X> struct back_
{
template<class U>
static U&& get(typename match<X, eat>::type..., U&& u)
{
return static_cast<U&&>(u); // forward
}
};
// simple macro to avoid repetition for trailing return type.
#define RETURNS(exp) -> decltype(exp) { return exp; }
// get the last value …我有一个constexpr类Debug：
struct Debug {
constexpr Debug(bool a, bool b, bool c) : a(a), b(b), c(c) {}
bool a, b, c;
constexpr bool get() const { return a; }
};
int main() {
Debug dbg(true, false, false); // is dbg constexpr object?
constexpr Debug dbg2(0, 0, 0); // is constexpr redundant here?
}
如您所见，这dbg是一个constexpr对象，因为它是用constexpr构造函数初始化的，所以如果我用constexpr对其进行限定，那有什么意义呢？
dbg和dbg2。谢谢。我最近发现了这种insertAdjacentHTML方法,它是一个神派.因此,我想知道这种方法的支持程度.IE有吗？那Chrome怎么样？
这不是一个技术问题,而是一个c ++设计问题.
通常,似乎我必须设计程序,必须管理一些具有某种连接的协议,解析阶段和抽象视图.通常情况下,我会尝试将我的程序设计为最前沿的关注点.
我一直以对象的"堆栈"结束,系统位于解析器的顶部,而解析器又位于连接的顶部(通常有更多的层).然后,这些对象使用成员函数调用来调用它下面的层(Tx),并使用回调(std::function通常)来捕获来自其他方向(Rx)的信息.
这种设计似乎非常低,因为它增加了复杂性,每层都必须有一个逐渐变大的构造函数等等.另外因为连接通常使用类似ASIO的东西,回调通常在不同的线程上,因此很难推断线程安全.
是否有更好的设计模式或成语代表这种结构/功能？
一个简单的例子
class basic_connection {
basic_connection(std::string address);
void send(std::string);
std::function<void(std::string)> on_receive;
};
我有一些像这样的类,它拥有该层的状态,并通过它们的公共成员函数和回调粘合在一起.
上面的层接收网络和调用的命令数据进程basic_connection::send.并从原始数据中获取原始数据basic_connection并转换为未处理的上层图层的命令.
我忘了提到的另一个问题是你最终通过堆栈转发了一些接口,例如,顶层仍然需要知道连接状态.
当作为引用返回并作为指针直接传递给另一个函数时,静态变量会发生什么？显然,变量在函数返回后仍然存在,但关于这整个概念的一些事情让我感到烦恼.此时是数据后续的内存,被静态变量占用,被释放了吗？当我不再需要它时,运行时会神奇地注意到它,比如某种垃圾收集吗？
举个例子:
SDL_Rect* XSDL_RectConstr(int x, int y, int w, int h)
{
static SDL_Rect rect;
rect.x = x;
rect.y = y;
rect.w = w;
rect.h = h;
return ▭
}
void mainLoop()
{
while(isRunning)
{
pollEvents();
SDL_BlitSurface(someSurface, XSDL_RectConstr(0, 0, 100, 100), screen, NULL);
SDL_Flip(screen);
}
}
rectSDL_BlitSurface()返回后会发生什么？我看不出它什么时候会被释放.这不是某种内存泄漏吗？
你好,我有部分专业化的问题.我想要做的是拥有一个具有模板成员函数的类,该函数将给定值解释为用户指定的值.例如,类名是Value,这是我想要做的片段:
int *ptr1 = new int;
*ptr1 = 10;
Value val1 = ptr1;
int *ptr2 = val1.getValue<int*>();
Value val2 = 1;
int testVal = val2.getValue<int>();
以下是我实现此类的方法:
struct Value {
Value(void *p) : val1(p){}
Value(int i) : val2(i){}
template<typename T>
T getValue();
void *val1;
int val2;
};
template<typename T>
T* Value::getValue<T*>() {
return reinterpret_cast<T*>(val1);
}
template<>
int Value::getValue<int>() {
return val2;
}
当我编译时,我收到以下错误:
错误C2768:'Value :: getValue':非法使用显式模板参数
基本上它抱怨代码的指针模板部分:
template<typename T>
T* Value::getValue<T*>() {
return reinterpret_cast<T*>(val1);
}
我知道这个问题可以通过一个简单的联合来实现,但是这个代码是一个更大代码的精简版本.
有人知道问题可能是什么吗？我想要做的是在使用指针时分离一个代码,而在不使用指针时分开.我真的被卡住了,我总是调查而不是问,但我没有找到任何关于它的好信息.
我有一个int的向量,我想要添加多个值,但是太多的值要添加很多push_backs.是否有任何方法可以在向量的末尾添加多个值.有点像这样:
std::vector<int> values
values += {3, 9, 2, 5, 8, etc};
我发现boost有类似的东西,但我不想包含boost.
#include <boost/assign/std/vector.hpp>
using namespace boost::assign;
{
std::vector<int> myElements;
myElements += 1,2,3,4,5;
}
这似乎是这样声明的:
template <class V, class A, class V2>
inline list_inserter<assign_detail::call_push_back<std::vector<V,A> >, V>
operator+=( std::vector<V, A>& c, V2 v )
{
return push_back( c )( v );
}
是否有任何C++/C++ 11方法可以做到这一点,如果没有,它将如何实现？