相关疑难解决方法(0)

最近我碰到了C++的Singleton设计模式的实现/实现.看起来像这样(我从现实生活中采用了它):

// a lot of methods are omitted here
class Singleton
{
   public:
       static Singleton* getInstance( );
       ~Singleton( );
   private:
       Singleton( );
       static Singleton* instance;
};

从这个声明我可以推断出实例字段是在堆上启动的.这意味着存在内存分配.对我来说完全不清楚的是,什么时候内存将被解除分配？还是有漏洞和内存泄漏？好像在实施中存在问题.

我的主要问题是,如何以正确的方式实施它？

我想为SO准备一些教育工具,这应该有助于初学者(和中级)程序员识别和挑战他们在C,C++及其平台中的无根据的假设.

例子:

• "整数环绕"
• "每个人都有ASCII"
• "我可以将函数指针存储在void*中"

我认为可以在各种平台上运行一个小型测试程序,它运行"合理的"假设,根据我们在SO中的经验,通常是由许多缺乏经验/半经验的主流开发人员制作的,并记录他们在各种机器上打破的方式.

这样做的目的不是要证明做某事是"安全的"(这是不可能做到的,测试只有在他们破坏的情况下证明了什么),而是向最难以理解的个体展示最不起眼的表达方式如果它具有未定义或实现定义的行为,则在另一台机器上中断..

为此,我想问你:

• 如何改进这个想法？
• 哪些测试会很好,它们应该是什么样的？
• 您是否可以在可以获得的平台上运行测试并发布结果,以便最终得到平台数据库,它们之间的区别以及为什么允许这种差异？

这是测试玩具的当前版本:

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <stddef.h>
int count=0;
int total=0;
void expect(const char *info, const char *expr)
{
    printf("..%s\n   but '%s' is false.\n",info,expr);
    fflush(stdout);
    count++;
}
#define EXPECT(INFO,EXPR) if (total++,!(EXPR)) expect(INFO,#EXPR)

/* stack check..How can I do this better? */
ptrdiff_t check_grow(int k, int *p)
{
    if (p==0) p=&k;
    if (k==0) return &k-p;
    else return check_grow(k-1,p);
}
#define BITS_PER_INT (sizeof(int)*CHAR_BIT)

int bits_per_int=BITS_PER_INT;
int int_max=INT_MAX; …

最近在一次采访中有一个以下客观类型的问题.

int a = 0;
cout << a++ << a;

回答:

一个.10
b.01
c.未定义的行为

我回答了选择b,即输出为"01".

但令我惊讶的是,一位采访者告诉我,正确的答案是选项c:undefined.

现在,我确实知道C++中序列点的概念.以下语句的行为未定义:

int i = 0;
i += i++ + i++;

但根据我对该陈述的理解cout << a++ << a,ostream.operator<<()将被召唤两次,先是ostream.operator<<(a++)后来ostream.operator<<(a).

我还检查了VS2010编译器的结果,其输出也是'01'.

我记得首先在STL中学习矢量,经过一段时间后,我想在我的一个项目中使用bool矢量.在看到一些奇怪的行为并做了一些研究之后,我了解到一个bool矢量并不是真正的bool矢量.

在C++中还有其他常见的陷阱需要避免吗？

在C中调用时,可以假设函数参数的评估顺序吗？根据以下程序,我执行时似乎没有特定的顺序.

#include <stdio.h>

int main()
{
   int a[] = {1, 2, 3};
   int * pa; 

   pa = &a[0];
   printf("a[0] = %d\ta[1] = %d\ta[2] = %d\n",*(pa), *(pa++),*(++pa));
   /* Result: a[0] = 3  a[1] = 2    a[2] = 2 */

   pa = &a[0];
   printf("a[0] = %d\ta[1] = %d\ta[2] = %d\n",*(pa++),*(pa),*(++pa));
   /* Result: a[0] = 2  a[1] = 2     a[2] = 2 */

   pa = &a[0];
   printf("a[0] = %d\ta[1] = %d\ta[2] = %d\n",*(pa++),*(++pa), *(pa));
   /* a[0] = 2  a[1] = 2 a[2] = …

When have you ever personally come upon the halting problem in the field? This can be when a co-worker/boss suggested a solution which would violate the fundamental limits of computation, or when you realized yourself that a problem you were trying to solve was, in fact, impossible to solve.

我最近想出来的时候是研究类型检查器.我们班级意识到编写一个完美的类型检查器是不可能的(一个可以接受所有运行没有类型错误的程序,并拒绝所有运行类型错误的程序),因为这实际上可以解决暂停问题.另一个是当我们在同一个类中意识到在类型检查阶段不可能确定除法是否会出现零,因为检查一个数字在运行时是否为零,也是暂停问题的一个版本.

通过阅读C++标准,我一直都知道C++中的整数基本类型的大小如下:

sizeof(char) <= sizeof(short int) <= sizeof(int) <= sizeof(long int)

我从3.9.1/2中推断出这个:

2. 有四种带符号的整数类型:"signed char","short int","int"和"long int".在此列表中,每种类型至少提供与列表中前面的存储一样多的存储空间.简单的int具有执行环境的体系结构所建议的自然大小

此外,大小char由3.9.1 /描述为:

1. [...]大到足以存储实现的基本字符集的任何成员.

1.7/1以更具体的术语定义:

1. C++内存模型中的基本存储单元是字节.一个字节至少足以包含基本执行字符集的任何成员,并且由连续的位序列组成,其数量是实现定义的.

这导致我得出以下结论:

1 == sizeof(char) <= sizeof(short int) <= sizeof(int) <= sizeof(long int)

where sizeof告诉我们这个类型的字节数.此外,它是实现定义的字节中有多少位.我们大多数人可能习惯于处理8位字节,但标准表示n字节中有位.

在这篇文章中,Alf P. Steinbach说:

long保证(至少)32位.

根据标准,这一切都在我理解C++基本类型的大小面前.通常情况下,我只是将这句话视为初学者错误,但由于这是Alf,我认为值得进一步调查.

那么,你呢？标准长期保证至少为32位？如果是这样,请具体说明如何进行此保证.我只是没有看到它.

1. C++标准特别指出,为了了解C++,你必须知道C(1.2/1)¹

2. C++标准隐含地定义了long可容纳的值的最小限制LONG_MIN- LONG_MAX ²

所以无论多大long,它都必须足够大才能将LONG_MIN保持为LONG_MAX.

但Alf和其他人特别指出,long必须至少为32位.这就是我想要建立的.C++标准明确指出一个字节中的位数没有指定(可能是4,8,16,42)那么连接如何能够容纳数字LONG_MIN-LONG_MAX至少为32位？

(1)1.2/1:以下参考文件对于本文件的应用是必不可少的.凡是注日期的引用文件,仅引用的版本适用.凡是不注日期的引用文件,其最新版本(包括所有的修改单)适用于本标准.

• ISO/IEC 2382(所有部分),信息技术 - 词汇
• ISO/IEC 9899:1999,编程语言 - C.
• ISO/IEC 10646-1:2000,信息技术 - 通用多八位字节编码字符集(UCS) - 第1部分:体系结构和基本多语言平面

(2)定义 …

为什么++ i是l值而i ++不是？

在一个已编译的程序中(假设是C或C++,但我想这个问题可以扩展到任何带有调用堆栈的非VM语言) - 通常当你溢出堆栈时,会出现分段错误:

堆栈溢出是[a]原因,分段错误就是结果.

但这总是如此吗？堆栈溢出是否会导致其他类型的程序/操作系统行为？

我也问过非Linux,非Windows操作系统和非X86硬件.(当然,如果你没有硬件内存保护或操作系统支持(例如MS-DOS)那么就没有分段错误;我问的是你可能会遇到分段错误的情况但是还会发生其他事情).

注意:假设以外的堆栈溢出,该方案是有效的,而不是试图访问数组超出边界,取消引用无效指针等

我在我的探查器中闲逛一段时间试图弄清楚如何加速一个常见的日志解析器,这个解析器在日期解析时遇到瓶颈,我尝试了各种算法来加快速度.

我尝试过的对我来说最快的东西也是迄今为止最具可读性,但可能是非标准的C.

这在GCC,icc和我真正古老而挑剔的SGI编译器中运行良好.因为它是一个非常易读的优化,它不是我想要的吗？

static int parseMonth(const char *input) {
    int rv=-1;
    int inputInt=0;
    int i=0;

    for(i=0; i<4 && input[i]; i++) {
        inputInt = (inputInt << 8) | input[i];
    }

    switch(inputInt) {
        case 'Jan/': rv=0; break;
        case 'Feb/': rv=1; break;
        case 'Mar/': rv=2; break;
        case 'Apr/': rv=3; break;
        case 'May/': rv=4; break;
        case 'Jun/': rv=5; break;
        case 'Jul/': rv=6; break;
        case 'Aug/': rv=7; break;
        case 'Sep/': rv=8; break;
        case 'Oct/': rv=9; break;
        case 'Nov/': rv=10; break;
        case …