小编luk*_*uke的帖子

我有一个类看起来像:

class Foo
{
public:
    Foo();
    virtual ~Foo();

private:
    Odp* bar;
};

我希望初始化bar为NULL.这是最好的方法吗？

Foo::Foo() : bar(NULL)
{
}

此外,析构函数是否必须是虚拟的？(如果这是真的,那么构造函数也必须是虚拟的吗？)

我知道在C#中你可以使用String.Format方法.但是你如何在C++中做到这一点？是否有一个函数允许我将一个字节转换为十六进制？只需将8字节长的数据转换为Hex,我该怎么做？

虽然修改一些老的C++代码,我在几个跑bitflags定义为枚举.

enum FooFlags
{
    FooFlag1 = 1 << 0,
    FooFlag2 = 1 << 1,
    FooFlag3 = 1 << 2
    // etc...
};

这并不罕见,但是一旦你开始组合标志就会让你感到困扰,你会丢失类型信息.

int flags = FooFlag1 | FooFlag2;   // We've lost the information that this is a set of flags relating to *Foo*

一些搜索结果显示我并不是唯一 一个被这个困扰的人.

一种替代方法是将标志声明为#defines或const积分,因此按位运算不会转换类型(可能).这个问题是它允许我们的位设置与不相关的标志,通过整数或其他枚举混合.

我熟悉std :: bitset和boost :: dynamic_bitset,但两者都不是为解决我的问题而设计的.我正在寻找的东西就像C#的FlagsAttribute.

我的问题是,对于(更多)类型安全的位标志,还有哪些其他解决方案？

我将在下面发布我自己的解决方案.

一些程序员说,"朋友功能打破了C++中的封装".一些程序员还说,"朋友的功能不会破坏封装;相反,他们自然会扩展封装屏障"

这是什么意思？..

如果朋友函数打破了C++中的封装,那么如何？

并c99/c++03保证&a+1 > &a永远是真的吗？

例如,有一个(类似c)std::copy,和

int a = 0 ;
int b[9] ;
std__copy(&a , &a+1 , b) ;

这总是有效吗？

我在Release和Debug版本的程序结果中发现了一些差异.经过一些研究后,我意识到一些浮点优化会导致这些差异.我已经通过使用fenv_access pragma来禁用某些关键方法的某些优化来解决了这个问题.

考虑到这一点,我意识到使用fp:strict模型而不是fp可能更好:因为它的特性在我的程序中是精确的,但我担心性能.我试图找到一些关于fp的性能问题的信息:严格或精确和严格模型之间的性能差异,但我发现的信息非常少.

有人对这个有了解吗？？

提前致谢.

下面的代码是检查执行相同解决方案的三种不同方式的性能.

    public static void Main(string[] args)
    {
        // for loop
        {
            Stopwatch sw = Stopwatch.StartNew();

            int accumulator = 0;
            for (int i = 1; i <= 100000000; ++i)
            {
                accumulator += i;
            }

            sw.Stop();

            Console.WriteLine("time = {0}; result = {1}", sw.ElapsedMilliseconds, accumulator);
        }

        //Enumerable.Range
        {
            Stopwatch sw = Stopwatch.StartNew();

            var ret = Enumerable.Range(1, 100000000).Aggregate(0, (accumulator, n) => accumulator + n);

            sw.Stop();
            Console.WriteLine("time = {0}; result = {1}", sw.ElapsedMilliseconds, ret);
        }

        //self-made IEnumerable<int>
        {
            Stopwatch sw = Stopwatch.StartNew();

            var ret = …

假设我们有3数字N,x而且y总是数字>=1.

N值将大于x和y和x会大于y.

现在我们需要找到1到N之间的所有数字之和,它们可以被x或y整除.

我想出了这个:

sum = 0;
for(i=1;i<=N;i++)
{
  if(i%x || i%y)
    sum += i;
}

有没有更好的方法来找到避免for循环的总和？

我现在已经好好打了很多天,但没有更好的东西.

如果值N具有上限,我们可以使用查找方法来加速该过程.

感谢大家.

我想要一个基于C/C++的解决方案.是否有内置函数来执行此操作？或者我必须编写算法代码？

请考虑以下代码:

void ListenerImpl::attach(boost::shared_ptr<ISubscriber> subscriber)
{
    boost::unique_lock<boost::mutex>(mtx);
    subscribers.push_back(subscriber);
}

void ListenerImpl::notify(MsgPtr msg)
{
    boost::unique_lock<boost::mutex>(mtx);

    //notify all subscribers
    BOOST_FOREACH(boost::shared_ptr<ISubscriber> subscriber, subscribers){
        subscriber->update(msg);
    }

}

(这是GoF中描述的观察者模式的实现.)这里的用户干预是保护attach()和notify()不同时运行,因此boost :: unique_lock.目标是保护subscribers容器.

但确实很难注意到锁实际上只是暂时的(仔细看,没有为它们指定名称).因此,当临时被破坏时,互斥锁上的锁定将被立即释放,即代码不是线程安全的.我希望在这种情况下编译器警告.像"未使用的临时"之类的东西.

更糟糕的是,cppcheck也不会认识到这个错误.(cppcheck:ac/c ++代码分析工具http://sourceforge.net/apps/mediawiki/cppcheck/index.php?title=Main_Page)

Gcc对未使用的变量发出警告.这里的临时变量是一个未使用的变量,绝对是程序员注意力不集中的结果.那么,为什么在这种情况下没有警告呢？发现这种情况可能太复杂了吗？

我记得读过一本关于标准C编程语言的书.它在某种情况下说C你可以写i = + 1,等于i + = 1.所以i(运算符)=(表达式)等于i =(运算符)(表达式).我从来没有见过这种C,是否有人可以解释这个？

最好的问候和谢谢,范