C++保证编译单元(.cpp文件)中的变量按声明顺序初始化.对于编译单元的数量,此规则分别适用于每个(我的意思是类外的静态变量).
但是,变量的初始化顺序在不同的编译单元中是不确定的.
我在哪里可以看到关于gcc和MSVC的这个订单的一些解释(我知道依赖于这是一个非常糟糕的想法 - 它只是为了理解我们在迁移到新的GCC主要和不同操作系统时遗留代码可能遇到的问题) ？
我发现strncpy_s()在VS2013下定义为
errno_t __cdecl strncpy_s
(
_Out_writes_z_(_SizeInBytes) char * _Dst,
_In_ rsize_t _SizeInBytes,
_In_reads_or_z_(_MaxCount) const char * _Src,
_In_ rsize_t _MaxCount
);
rsize_t 是:
typedef size_t rsize_t;
我认为这是Visual Studio的一个技巧.但是,我发现此功能在此页面上定义如下
errno_t strncpy_s
(
char *restrict dest,
rsize_t destsz,
const char *restrict src,
rsize_t count
);
为什么rsize_t定义在这里？如果size_t在这里使用怎么办？有什么特殊情况可以使用rsize_t吗？
我想存储一组键值项,常见的方法可能是:
// the JSON data may store several data types, not just key value lists,
// but, must be able to identify some data as a key value list
// --> more "common" way to store a key value array
{
[
{"key": "slide0001.html", "value": "Looking Ahead"},
{"key": "slide0008.html", "value": "Forecast"},
{"key": "slide0021.html", "value": "Summary"},
// another THOUSANDS KEY VALUE PAIRS
// ...
],
"otherdata" : { "one": "1", "two": "2", "three": "3" }
}
但是,当有很多对/项目时,字符串长度变得禁止,我想要一个紧凑的方式,这可能是一个例子:
// --> (1) a …这是一个奇怪的oop问题.我想创建一组对象(在设计时已知),每个对象都具有与之关联的某些功能.我可以通过给出包含'delegates'的对象属性来做到这一点:
public class StateTransition {
Func<bool> Condition { get; set; }
Action ActionToTake { get; set; }
Func<bool> VerifyActionWorked { get; set; }
}
StateTransition foo = new StateTransition {
Condition = () => {//...}
// etc
};
或者,我可以使用抽象类并为我想要创建的每个对象实现它:
public abstract class StateTransition {
public abstract bool Condition();
public abstract void ActionToTake();
public abstract bool VerifyActionWorked();
}
class Foo : StateTransition {
public override bool Condition() {//...}
// etc
}
Foo f = new Foo();
我意识到这两种方法的实际后果(在设计时间与运行时间创建)是完全不同的.
如何选择适合我的应用的方法？
我有2个案例,一个方法可以被认为是一个工厂设计模式,这个例子是在C#,altought,可以应用于其他编程语言:
enum NinjaTypes {
Generic,
Katanna,
StarThrower,
Invisible,
Flyer
}
public class Ninja {
public string Name { get; set; }
public void jump() { ... }
public void kickAss() { ... }
}
public class KatannaNinja: Ninja {
public void useKatanna() { ... }
}
public class StarNinja: Ninja {
public void throwStar() { ... }
}
public class InvisibleNinja: Ninja {
public void becomeInvisible() {...}
public void becomeVisible() {...}
}
public class FlyNinja: Ninja {
public void fly() …如何强制通过 GLR 方法解决 shift\reduce 冲突？
假设我希望解析器为自己解决右移运算符和模板参数的两个右尖括号之间的冲突。我让词法分析器将 2 个连续的“>”符号作为单独的标记传递，而不将它们合并为一个“>>”标记。然后我将这些规则放在语法中：
operator_name:
"operator" ">"
| "operator" ">" ">"
;
我希望这是一个转变\减少冲突。如果我有具有左结合性的 ">" 的标记声明，则不会发生冲突。所以我必须删除标记优先级\关联性声明，但这会导致许多其他冲突，我不想通过为每个冲突规则指定上下文优先级来手动解决这些冲突。那么，有没有办法在声明令牌的同时强制转换\减少冲突？
我有以下类使用3个不同的映射:键总是字符串,而值可以是字符串,整数或浮点数.
class MyMaps
{
public:
template<typename T> void addKey(const std::string& key);
void addValue(const std::string& key, const std::string& value);
void addValue(const std::string& key, int value);
void addValue(const std::string& key, float value);
private:
std::map<std::string, std::string> stringFields;
std::map<std::string, int> intFields;
std::map<std::string, float> floatFields;
};
这些addValue()函数只是将新对添加到相关地图中.我正在做的是addKey()模板功能:
/** Add only a key, the related value is a default one and is specified by template parameter T. */
template<typename T>
void MyMaps::addKey(const string& key)
{
if (typeid(T) == typeid(string))
{
stringFields.insert(pair<string, string>(key, …我正在对一个系统进行逆向工程并创建一个类图。
代码类似于以下示例：
class B
{
}
class C
{
}
class A
{
C GetC()
{
return new C();
}
void Foo()
{
B b = new B;
C c = GetC(); // this function returns a reference to an object of type C
}
}
我想知道我是否有这段代码，A和B，A和C类之间是什么关系？
假设我有一个网站,当访问时,显示今天你的幸运字.问题是每个单词都可以只为一个人幸运,所以你需要快速访问网站.以下是带有幸运字的示例表:
+---------------------+
| lucky_word |
+---------------------+
| cat |
| moon |
| piano |
| yellow |
| money |
+---------------------+
我的问题是:如何防止两个(或更多)用户同时访问该表.我假设每个用户从现有表中读取第一个lucky_word,并且立即删除所选单词,因此它不会是下一个用户的幸运单词.例如,我想避免将猫展示给多个访客.
我应该使用适当的MySQL查询或PHP代码中的某些行或两者来解决这个问题吗？
我正在 Haskell 中实现一个编译器，将源语言编译为目标语言（类似汇编）。
出于调试目的，需要源映射将目标语言汇编指令映射到其相应的源位置（行和列）。
我已经广泛搜索了编译器实现，但没有一个包含源映射。
谁能指出我如何生成源地图的正确方向？
代码示例、书籍等。Haskell 优先，其他语言也欢迎。
概述：
我正在使用一个业余应用程序。我希望我的程序能够坚持“普通C”。
由于多种原因，我必须使用支持“ Plain C”的C ++编译器以及相关的编程环境程序。并且，出于相同的原因，我无法更改为其他编译器。
而且，我无意中编码了一些C ++功能。
例如，我没有使用名称空间或类。我当前的编程工作不是“普通c”或“ c ++”，而且我已经有一段时间没有使用它们了，所以，我可能已经忘记了哪些东西仅是“普通c”。
我在Internet上浏览了“ Plain C”示例。我发现许多其他开发人员也发布了混合的“ plain c”和“ c ++”示例（其中一些是无意的）。
我正在使用一些动态分配的结构。我一直在使用“ malloc”，但是我宁愿使用“ new”。我以为“ plain c”的某些新标准和编译器版本允许“ new”，但似乎我错了。
似乎“新”是“ C ++”功能，并且如果我真的只想制作“普通c”，则应该使用“ malloc”。
我之所以要坚持使用“普通C”，是因为我正在跨平台的非GUI库/工具中工作。
我当前的平台是“ Windowze”，我的开发环境是：
（1）代码块（MinGW）
（2）流血DevCPP
（3）Borland CBuilder 6
虽然，我的目标是也将其迁移到Linux，以及其他平台和其他（命令行）编译器。
快速未测试示例：
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
struct MyData_T
{
int MyInt;
char MyName[512];
char *MyCharPtr;
};
typedef
struct MyData_T *MyData_P;
MyData_P newData(char* AName)
{
MyData_P Result = null;
Result = malloc(sizeof(MyData_T));
strcpy(Result->MyName, AName, strlen(AName));
// do other stuff with …