工作案例:
template<typename T>
class threadsafe_queue
{
private:
mutable std::mutex mut;
std::queue<T> data_queue;
public:
threadsafe_queue()
{}
threadsafe_queue(const threadsafe_queue& other)
{
std::lock_guard<std::mutex> lk(other.mut);
data_queue=other.data_queue;
}
};
案例应该会失败:注意不mutable上std::mutex mut;
template<typename T>
class threadsafe_queue
{
private:
std::mutex mut;
std::queue<T> data_queue;
public:
threadsafe_queue()
{}
threadsafe_queue(const threadsafe_queue& other)
{
std::lock_guard<std::mutex> lk(other.mut);
data_queue=other.data_queue;
}
};
我已经尝试过上面列出的两种情况,并且编译没有问题.我假设内部lock_guard调用mutex :: lock函数,它本身不是const函数.
问题>为什么我们可以从复制构造函数中的const对象锁定互斥锁？
因此，我目前正在使用C ++进行学校项目，而我对此并不十分熟悉。我想创建一个类，其中包含我尝试的所有常量（string，int，double，own类），它在Java中一直对我有用：
class Reference {
//Picture-Paths
public:
static const std::string deepSeaPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
static const std::string shallowWaterPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
static const std::string sandPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
static const std::string earthPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
static const std::string rocksPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
static const std::string snowPath = "E:\\Development\\C++\\Material\\terrain\\deep_sea.tga";
};
但是，在C ++中，出现以下错误：
Error C2864 'Reference::Reference::earthPath': a static data member with an in-class initializer must have non-volatile const integral type bio-sim-qt e:\development\c++\bio-sim-qt\bio-sim-qt\Reference.hpp 16 1
所以我有什么办法可以存储例如这样的String-Constants吗？如果可以，还有更好的方法吗？如果否，还有其他方法（#define？）吗？
好的,我的程序有问题.我之前提出过一个问题,但没有人真正理解我的问题,所以我这次尝试一种新方法.
如果你很好奇,这是我的问题:
我的程序以形式接受参数
char* argv[],并且我无法指向正在argv[1]使用的任何东西LPWSTR,因为它只指向const wchar_t*对象.
这是一个新的事情,我试图解决我的问题(我已经尝试了多种东西,但我需要知道如何做我想的,或者如果可能的话)
基本上,我的想法是#define某种功能,它可以接受任何内容,argv[1]并const wchar_t*使用该值定义a .
像这样的东西:
#define path ((const wchar_t*)argv[1])
我不确定这是正确的方式(或者即使这是可能的)做我想做的事......
如果你有一个更好的方法来解决我的问题,请(请)告诉我如何帮助我,我一直在考虑这个很长的时间!
我的计划说明:
我正在制作一个接受争论的程序.参数是驱动器的名称,例如"F:".然后它使用
CreateFile带驱动器号的函数.如果你去这里,看看函数的第一个参数,我想你会看到我的意思....问题是,对于我来说,制作一个LPWSTR,我需要一个const wchat_t*对象....我希望这一次我的问题很清楚,上次人们真的不明白我想要做什么.
无论如何,谢谢!编辑1:这里是解决我的程序的行(这是我必须做的工作,没有参数)(我在这里使用固定值)
int main()
{
HANDLE device;
device = CreateFile(L"\\\\.\\F:", // Drive to open
GENERIC_READ | GENERIC_WRITE, // Access mode
FILE_SHARE_READ | FILE_SHARE_WRITE, // Share Mode
NULL, // Security Descriptor
OPEN_EXISTING, // How to create
0, // File attributes
NULL);
}
这是有参数(不起作用)
int main(int …我正在制作蛇游戏计划.我在类Snake中使用Body的deque代表蛇,当然Body是我定义的结构.以下是代码的一部分:
struct Body { // one part of snake body
int x, y, direction;
Body() : x(0), y(0), direction(UP) { }
Body(int ix, int iy, int id) : x(ix), y(iy), direction(id) { }
};
class Snake {
protected:
std::deque<Body> body;
// other members
public:
auto begin()->std::deque<Body>::const_iterator const { return body.cbegin(); }
auto end()->std::deque<Body>::const_iterator const { return body.cend(); }
// other members
};
在另一个函数construct_random_food中,我需要生成食物并确保它与蛇不一致.这是函数定义:
Food construct_random_food(int gameSize, const Snake& snake) {
static std::random_device rd;
static std::uniform_int_distribution<> u(2, gameSize + 1);
static …在OpenSSL中,一些函数需要使用const,但随后在其他方面需要我不要将const用于同一个变量.一个例子是当我创建一个新的BIGNUM我需要使用const然后释放它我不能有const.
有没有办法解决这个问题？什么是摆脱编译器警告的正确原因？
功能签名:
const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
void BN_free(BIGNUM *a);
违规代码:
EC_KEY *ec_key = ...;
/*const*/ BIGNUM *bignum = NULL;
bignum = EC_KEY_get0_private_key(ec_key);
BN_free(bignum);
编译器警告:
------------Without const in bignum------------:
warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
bignum = EC_KEY_get0_private_key(ec_key);
^
------------With const in bignum------------:
warning: passing argument 1 of ‘BN_free’ discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
BN_free(bignum);
^
In file included from /usr/include/openssl/asn1.h:74:0,
from /usr/include/openssl/objects.h:965,
from /usr/include/openssl/evp.h:94,
from ecdh.c:5:
/usr/include/openssl/bn.h:493:6: note: expected …//Person declaration
Class Person {
public:
Person();
const String getName() const;
private:
const String name;
};
//Person definition
#include "Person.h"
Player::Player() {
cout << "Enter name: ";
cin >> name;
}
如果我想在创建类时初始化人名,使用默认构造函数和初始化列表,但是name_的约束是const,我该怎么做呢？
我不相信名称的init列表会起作用,考虑到我的知识,init列表在创建时设置值,并且名称为const,此时不再可修改.
假设我创建了一个Person(); 在另一个类中,我怎样才能在该类实例的生命周期内将其名称初始设置为const？
我需要更正此代码,以便在每次单击时增加它.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Clicker</title>
<meta name="description" content="">
<style></style>
</head>
<body>
<button>Click!</button>
<script>
const counter = {
cnt: 0,
inc: function() {
cnt++;
console.log(cnt);
}
};
const button = document.getElementsByTagName('button')[0];
button.addEventListener('click', counter.inc, false);
</script>
</body>
</html>
我现在的解决方案工作正常,但不确定它背后的概念是什么,解决方案是:
inc: function() {
counter.cnt++;
console.log(counter.cnt);
}
我想Data在矢量中保存一些结构.这些结构通过索引(而不是指针)引用其他结构,以节省内存并使序列化更容易.为了遵循这些索引,我创建了一个类DataView,它为它提供了一个舒适的界面.它看起来像这样:
#include <iostream>
#include <vector>
struct Data
{
int id_next;
int id_prev;
int value;
};
class Foo;
class DataView
{
Foo * foo;
int index;
public:
DataView( Foo * foo_, int index_ )
: foo( foo_ ), index( index_ )
{
}
DataView next() const;
DataView prev() const;
int value() const;
int & value();
int id() const
{
return index;
}
};
class Foo
{
std::vector<Data> data;
public:
friend class DataView;
DataView dataview( int index ) …检查下面的代码.计数器声明为const.当你运行它时,它不应该允许它在任何情况下改变!
function increment(counter) {
counter += 1;
}
function test() {
const counter = 1;
increment(counter);
}
转换后,它会生成以下代码.这允许const计数器递增!
function increment(counter) {
counter += 1; // Counter is declared const, still it can be changed!
}
function test() {
var counter = 1;
increment(counter);
}
我只是试图理解,无论是Babel转换还是JavaScript规范都存在问题.
编辑:
我知道,与ES6不同,当前版本的JS不支持const.我担心的是,如果我使用已编译的JavaScript,我可能会遇到未知的const相关错误.那可以吗？
我偶然发现了我正在使用的共享指针的意外行为.
共享指针实现引用计数和分离(例如,复制),如果需要,包含非const使用的实例.
为实现此目的,对于每个getter函数,智能指针都有一个const和一个non-const版本,例如:operator T *()和operator T const *() const.
问题:比较指针值nullptr导致分离.
预期:我认为比较运算符总是会调用const版本.
简化示例:(
此实现没有引用计数,但仍显示问题)
#include <iostream>
template<typename T>
class SharedPointer
{
public:
inline operator T *() { std::cout << "Detached"; return d; }
inline operator const T *() const { std::cout << "Not detached"; return d; }
inline T *data() { std::cout << "Detached"; return d; }
inline const T *data() const { std::cout << "Not detached"; …const ×10
c++ ×7
c++11 ×3
javascript ×2
string ×2
babeljs ×1
c ×1
constants ×1
constructor ×1
createfile ×1
ecmascript-6 ×1
for-loop ×1
gcc ×1
lpwstr ×1
mutable ×1
openssl ×1
shared-ptr ×1
static ×1