我已经遇到过这个问题的调整.考虑:
class A {};
class B : private A {
static void foo();
};
void B::foo(){
B* bPtr1 = new B;
A* aPtr1 = dynamic_cast<A*>(bPtr1); // gives pointer
B* bPtr2 = dynamic_cast<B*>(aPtr1); // gives NULL
}
aPtr1事实上,因为它是类型的B*,并且因为我们已经完全访问B并继承了它A,所以我希望两个转换都可以工作.但他们没有; 为什么？还有另一种方法来实现这种演员吗？
注意:
foo()不是B的成员,两个演员都会失败.B从A公开继承,两个演员都可以.当我编写类模板,并且需要对这些类的成员进行完全特化时,Doxygen不会识别专门化 - 它只记录泛型定义,或者(如果只有特化)最后一个定义.这是一个简单的例子:
=== MyClass.hpp ===
#ifndef MYCLASS_HPP
#define MYCLASS_HPP
template<class T> class MyClass{
public:
static void foo();
static const int INT_CONST;
static const T TTYPE_CONST;
};
/* generic definitions */
template<class T>
void MyClass<T>::foo(){
printf("Generic foo\n");
}
template<class T>
const int MyClass<T>::INT_CONST = 5;
/* specialization declarations */
template<> void MyClass<double>::foo();
template<> const int MyClass<double>::INT_CONST;
template<> const double MyClass<double>::TTYPE_CONST;
template<> const char MyClass<char>::TTYPE_CONST;
#endif
=== MyClass.cpp ===
#include "MyClass.hpp"
/* specialization definitions */
template<>
void MyClass<double>::foo(){
printf("Specialized double foo\n"); …当我在模板类中专门化(静态)成员函数/常量时,我对于声明的去向感到困惑.
以下是我该做什么的一个例子 - 直接从IBM关于模板专业化的参考中找到:
=== IBM会员专业化示例===
template<class T> class X {
public:
static T v;
static void f(T);
};
template<class T> T X<T>::v = 0;
template<class T> void X<T>::f(T arg) { v = arg; }
template<> char* X<char*>::v = "Hello";
template<> void X<float>::f(float arg) { v = arg * 2; }
int main() {
X<char*> a, b;
X<float> c;
c.f(10); // X<float>::v now set to 20
}
问题是,如何将其分为header/cpp文件？通用实现显然在标题中,但是专业化呢？
它不能进入头文件,因为它具体,导致多重定义.但如果它进入.cpp文件,是调用X :: f()知道专门化的代码,还是它可能依赖于泛型X :: f()？
到目前为止,我只在.cpp中获得了专门化,标题中没有声明.我在编译甚至运行我的代码时遇到了麻烦(在gcc上,暂不记住版本),并且它的行为符合预期 - 认识到专业化.但A)我不知道这是正确的,我想知道是什么,以及B)我Doxygen文档出来靠不住的和非常误导的(更详细的介绍了一下以后的问题). …
据我所知,对于两个向量声明:
//TYPE 1
std::vector<cls> vec; //cls is user defined datatype(A class)
向量的内存在堆栈上分配,向量中的内容的内存在堆上分配.
以下声明也是如此(如果我错了,请纠正我):
//TYPE 2
std::vector<cls*> vec; //cls is user defined datatype(A class)
现在,当Type 1中的向量超出范围时,将为存储在其中的对象释放内存.
但是如果我插入如下的元素(假设我有正确的重载构造函数)然后向量超出范围,那么在类型2中会发生什么:
vec.push_back(new cls(5));
我明确地尝试调用clear但是没有调用析构函数.是否会自动释放内存并调用析构函数.如果不是那么如何实现.
此外,如果我将vector声明为vector,那么为向量分配的内存以及内容:
std::vector<cls*> *vec = new std::vector<cls*>;
快速上下文:我看到程序关闭时出现错误,这些错误源于全局成员之间的依赖关系(:: sigh ::,我知道,我知道).一个全局变量的析构函数可能引用另一个全局 - 如果那个已被破坏,那么事情就会变坏.
但这是一个特殊情况,我只是不知道行为是否定义明确:函数内部的静态变量.即使在程序关闭期间,我还能依赖该功能吗？或者是否可能会破坏静态成员,并且无论如何都会运行该函数而不创建新函数？
这是一个展示我感兴趣的玩具示例:
class Logger
{
public:
enum class Severity { DEBUG, INFO, WARNING, ERROR };
void Log(Severity sev, const std::string& msg)
{
LogImpl(FormatMessage(sev, msg));
}
Logger() { Log(Severity::INFO, "Logger active"); }
~Logger() { Log(Severity::INFO, "Logger inactive"); }
protected:
static std::string FormatMessage(Severity sev, const std::string& msg)
{
static const std::map<Severity, std::string> enum2str {
{Severity::DEBUG, "DEBUG"},
{Severity::INFO, "INFO"},
{Severity::WARNING, "WARNING"},
{Severity::ERROR, "ERROR"}
};
// Throws or crashes if enum2str is invalid, or uninitialized: …std::uniform_int_distribution接受任何<random> 的 PRNG，包括跨实现和平台一致的 PRNG。
然而，std::uniform_int_distribution它本身在不同的实现中似乎并不一致，所以我不能依赖能够复制它们，即使使用通用的 PRNG 和种子也是如此。这也会影响依赖的功能，例如std::shuffle()。
例如：
#include <random>
#include <iostream>
#include <string>
#include <algorithm>
template<typename T>
void printvector(const std::string& title, const std::vector<T>& v)
{
std::cout << title << ": { ";
for (const auto& val : v) { std::cout<<val<<" "; }
std::cout << "}" << std::endl;
}
int main()
{
const static size_t SEED = 770;
std::minstd_rand r1(SEED), r2(SEED), r3(SEED);
std::vector<int> vPRNG;
for (int i=0; i<10; ++i) { vPRNG.push_back((int)r1()); }
std::vector<size_t> …我正在尝试构建一个预编译的标头和一个可执行文件，如下所示：
g++ -g -Wall -std=c++17 \
-c ./src/pch.hpp -o ./build/pch.hpp.gch
g++ -g -Wall -std=c++17 \
-c ./src/*.cpp \
-I./build/ -include pch.hpp
该pch.hpp.gch文件被正确地创建。但是对于每个.cpp文件，我都会收到以下错误：
1 error generated.
<built-in>:1:10: fatal error: 'pch.hpp' file not found
#include "pch.hpp"
我认为根据gcc Precompiled Headers文档，我的编译行是正确的：
-I./build/告诉它将build目录添加到include搜索路径。-include pch.hpp在#include <pch.hpp>每个文件前添加指令。.gch为其每个#include指令搜索带后缀的预编译头。为什么我的编译行无法按预期运行？
我尝试过的某些方法确实可以给我带来更好的结果，但对我来说看起来并不正确。
如果我修改include来搜索.gch文件，则会找到该文件，与我期望的一致。即-include pch.hpp.gch，而不是-include pch.hpp。
但是随后，PCH被解释为二进制文件，并且编译失败：
g++ -g -Wall -std=c++17 \
-c ./src/*.cpp \
-I./build/ …Visual Studio突然不会在多个解决方案文件中显示多个项目的项目属性.
我在解决方案资源管理器中右键单击一个项目,并获得一个错误框: There are no property pages for the selection.
我认为问题不在于项目文件本身 - 我在从公共git存储库中提取的项目文件中看到了这一点,没有任何变化; 这些项目昨天正常工作,并继续为我办公室的朋友们工作.
我不知道以任何方式修改了Visual Studio设置.
知道可能导致这种情况的原因吗？
我在Windows 7(SP1)上使用Microsoft Visual Studio Professional 2015,版本14.0.24720.00 Update 1,我正在研究C++项目.
我正在使用gtest编写一个类型参数化的测试夹具,not declared in this scope当我尝试使用fixture类中的成员时,我看到了编译器错误.
当我没有使用类型参数化夹具时,我可以很好地访问类成员.当我正在使用一个类型参数化夹具,我可以使用this->(member name)访问该成员.但为什么我不能明确使用成员名称？有没有办法可以避免乱丢我的测试代码this->？
这是一个微不足道的再现:
Test_Sanity.h:
#include "gtest/gtest.h"
/* Using a member in a simple, non-paramed fixture: */
class SimpleFixture : public ::testing::Test {
protected:
int N;
};
TEST_F(SimpleFixture, FooTest) {
N=6;
ASSERT_LE(0,N);
}
/* Using a member in a type-parameterized fixture: */
template <typename PARAM_T>
class TypeParamFixture : public ::testing::Test {
protected:
int N;
};
TYPED_TEST_CASE_P(TypeParamFixture);
TYPED_TEST_P(TypeParamFixture, FooTest) {
N=6; /* COMPILE-ERROR: ‘N’ was not declared in this …在我的Python(2.7.3)代码中,我正在尝试使用ioctl调用,接受long int(64位)作为参数.我在64位系统上,因此64位int与指针大小相同.
我的问题是Python似乎不接受64位int作为fcntl.ioctl()调用的参数.它很高兴地接受一个32位的int或64位指针 - 但我需要的是传递一个64位的int.
这是我的ioctl处理程序:
static long trivial_driver_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
long err = 0;
switch (cmd)
{
case 1234:
printk("=== (%u) Driver got arg %lx; arg<<32 is %lx\n", cmd, arg, arg<<32);
break;
case 5678:
printk("=== (%u) Driver got arg %lx\n", cmd, arg);
break;
default:
printk("=== OH NOES!!! %u %lu\n", cmd, arg);
err = -EINVAL;
}
return err;
}
在现有的C代码中,我使用这样的调用:
static int trivial_ioctl_test(){
int ret;
int fd = open(DEV_NAME, O_RDWR);
unsigned long …