小编aJ.*_*aJ.的帖子

我正在调试一个多线程应用程序,并找到了内部结构CRITICAL_SECTION.我发现LockSemaphoreCRITICAL_SECTION的数据成员很有趣.

它看起来像是LockSemaphore一个自动重置事件(顾名思义不是信号量),并且当第一次线程等待Critcal Section某个其他线程锁定时,操作系统会静默创建此事件.

现在,我想知道关键部分总是更快吗？Event是一个内核对象,每个Critical部分对象都与事件对象相关联,那么Critical Section与其他内核对象(如Mutex)相比,如何更快？此外,内部事件对象如何实际影响Critical部分的性能？

这是结构CRITICAL_SECTION:

struct RTL_CRITICAL_SECTION
{
    PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
    LONG LockCount;
    LONG RecursionCount;
    HANDLE OwningThread;
    HANDLE LockSemaphore;
    ULONG_PTR SpinCount;
};

我正在浏览遗留代码并找到以下代码段:

MyClass::~MyClass()
{
   EnterCriticalSection(&cs);

//Access Data Members, **NO Global** members are being accessed here


  LeaveCriticalSection(&cs);
}

我想知道它有没有机会保护析构函数？

考虑一个场景:

1. Thread1 - About to execute any of the member function which uses critical section
2. Thread2-  About to execute destructor.

如果执行顺序是1 => 2那么它可能会起作用.但如果订单被撤销怎么办？

这是一个设计问题吗？

const int MIN_NUMBER = 4;
class Temp
{
public:

    Temp(int x) : X(x)
    {
    }

    bool getX() const
    {
        try
        {
            if( X < MIN_NUMBER)
            {
                //By mistake throwing any specific exception was missed out
                //Program terminated here
                throw ;
            }
        }
        catch (bool bTemp)
        {
            cout<<"catch(bool) exception";

        }
        catch(...)
        {
            cout<<"catch... exception";
        }
        return X;
    }

private:
    int X;
};



int main(int argc, char* argv[])
{
    Temp *pTemp = NULL;
    try
    {
        pTemp = new Temp(3);
        int nX = …

关于deque中的迭代器失效,我有点困惑.(在这个问题的背景下)

以下是摘自 - The C++标准库:教程和参考,作者:Nicolai M. Josuttis

除开头或结尾之外的任何元素的插入或删除都会 使引用双端队列元素的所有指针,引用和迭代器无效.

以下是SGI网站的摘录:

deque的迭代器失效的语义如下.Insert(包括push_front和push_back)使引用deque的所有迭代器无效.在双端队列中间擦除使所有引用双端队列的迭代器无效.只有当它指向已擦除的元素时,在双端队列的开头或结尾处擦除(包括 pop_front和pop_back)才会使迭代器无效.

恕我直言,deque是块的集合,第一个块在一个方向上生长,最后一个块在相反方向上生长.

  -   -  -  
  -   -  -
  |   -  -  ^
  |   -  -  |
  V   -  -  |
      -  -  -
      -  -  -

push_back, push_front 不应该对deque迭代器产生任何影响(我同意Josuttis).

什么是正确的解释？标准对此有何看法？

我们正在将VC++项目从Visual Studio 2003移植到Visual Studio 2008 SP1(9.0.30729.4148).依赖的外部库也使用Visual Studio 2008 SP1进行编译.

MainApp - Main application Compiled with VS SP1 9.0.30729.4148
ExtStaticLib1 - External static library compiled with VS  SP1 9.0.30729.4148
ExtDynamicDll1 - External DLL compiled with VS  SP1 9.0.30729.4148

主应用程序有两种部署方案:

• 具有用户管理员权限的计算机:我们建议在使用应用程序MainApp之前先安装Visual Studio可再发行组件包.这很有效,因为用户具有管理员权限,并且安装可再发行组件包没有问题.应用程序自动链接到WinSxS文件夹中的VC redist DLL.
• 具有非管理员用户的计算机:此方案存在问题.用户没有管理员权限.因此,无法安装VS2008SP1 redistrtibutable包.

我们正在做以下事来解决这个问题:

• 使用宏_BIND_TO_CURRENT_OPENMP_VERSION(对于MainApp中的所有项目)编译MainApp目标.

• 将VS2008SP1可再发行DLL分发为专用程序集,并将它们复制到应用程序安装目录中.

问题:

1. 使用标志_BIND_TO_CURRENT_VCLIBS_VERSION是否有任何副作用(特别是当VC可再发行程序包和私有VC redist程序集一起存在时)？
2. 我们对外部库ExtStaticLib1,ExtDynamicDll1没有太多控制权,因此它们不会使用宏_BIND_TO_CURRENT_OPENMP_VERSION进行编译.但它们已经使用VSSp1编译.这个设置会有任何问题吗？
3. 如果有更新版本的VS可再发行组件(比9.0.30729.4248更新),是否会出现任何问题.

谢谢.

我有这个基本的怀疑.STL标头没有.h扩展名.

#include <vector>
#include <map>

这背后有什么具体原因吗？有人知道这背后的历史,请分享.

编辑:

@GMan找到了迈克尔伯尔的答案 来解决这个问题.

我正在阅读有关volatile成员函数的信息并且遇到了一个肯定,即成员函数可以同时是const和volatile.我没有真正使用这样的东西.任何人都可以分享他们在成员函数作为const和volatile一起实际使用的经验.

我写了小班来测试同样的东西:

class Temp
{
public:

    Temp(int x) : X(x)
    {
    }

    int getX() const volatile
    {
        return X;
    }

    int getBiggerX()
    {
        return X + 10;
    }
private:
    int X;
};

void test( const volatile Temp& aTemp)
{
    int x = aTemp.getX();
}

int main(int argc, char* argv[])
{
    const volatile Temp aTemp(10);
    test(aTemp);

    return 0;
}

对于特定于类的new_handler实现,我在"有效的c ++"一书中遇到了以下示例.这看起来在多线程环境中存在问题,我的问题是如何在多线程环境中实现类特定的new_handler？

void * X::operator new(size_t size)
{
    new_handler globalHandler =                // install X's
    std::set_new_handler(currentHandler);    // handler
    void *memory;
    try {                                      // attempt
        memory = ::operator new(size);           // allocation
    }
    catch (std::bad_alloc&) {                  // restore
        std::set_new_handler(globalHandler);     // handler;
        throw;                                   // propagate
    }                                          // exception
    std::set_new_handler(globalHandler);       // restore
                                               // handler
    return memory;
}

我有一个填充了百万条记录的oracle数据库.我正在尝试编写一个SQL查询,该查询根据特定条件从数据库返回第一个"N"个排序记录(比如100条记录).

SELECT * 
FROM myTable 
Where SIZE > 2000 
ORDER BY NAME DESC

然后以编程方式选择前N个记录.

这种方法的问题是:

• 查询结果为50万条记录,"ORDER BY NAME"导致所有记录按降序排序在NAME上.这种分类花费了大量时间.(将近30-40秒.如果我省略ORDER BY,则只需1秒钟).
• 排序后,我只对前N(100)条记录感兴趣.因此,完整记录的排序无用.

我的问题是:

1. 是否可以在查询中指定"N"？(这样排序仅适用于N条记录,查询变得更快).
2. 在SQL中有任何更好的方法来改进查询以仅排序N个元素并在快速时间内返回.

我们使用Visual Studio 2003(VC71)进行编译.为了减少编译时间,我们更改了构建脚本,以便为每个CPP文件生成预编译头文件(.pch).

makefile中使用的选项:

/Yc"StdAfx.h"
/Fp"StdAfx.pch"

这样,目标的编译时间减少了30%.但是,任何人都可以帮助我理解即使每次编译每个CPP文件时生成pch文件,它如何减少编译时间.

还有,这是正确的方法吗？我们应该使用Yc和Yu组合吗？我不能使用/ Yu选项,因为pch文件应该至少生成一次.