小编tuk*_*uks的帖子

看看这段代码:

#include <cmath>
#include <iostream>
using namespace std;
class Sphere
{
    double r;
public:
    double V() const { return (4/3) * 3.14 * pow(r,3); }
    bool equal(const Sphere& s) const
    {
        cout  << V() << " == " << s.V() << " : " << ( V() == s.V() );
        return ( V() == s.V() );

    }

    explicit Sphere(double rr = 1): r(rr){}

};
main()
{
    Sphere s(3);
    s.equal(s);
}

输出是84.78 == 84.78 : 0指同一方法每次都不返回相同的值,即使所有参数都是静态的？

但是如果我写的3.0不是 …

我创建了一个gulp任务,用于使用browserify捆绑模块,我使用watchify来监视更改.以下是watchify的gulp任务:

gulp.task('watch:browserify', function () {
    var opts = assign({}, watchify.args, {
        entries: ['./js/app.js'],
        debug: true,
        basedir: './app/',
        paths: ['./lib']
    });

    var b = watchify(browserify(opts));

    b.on('update', function () {
        bundle();
    });

    function bundle() {
        gutil.log(gutil.colors.blue("Starting Browserify..."));
        var time = Date.now();
        return b.bundle()
            .on('error', gutil.log.bind(gutil, gutil.colors.red('Browserify Error')))
            .pipe(source('bundle.js'))
            .pipe(buffer())
            .pipe(sourcemaps.init({loadMaps: true}))
            .pipe(sourcemaps.write('.'))
            .pipe(gulp.dest('app'))
            .on('end', function () {
                var duration = Date.now() - time;
                gutil.log(gutil.colors.blue('Finished Browserify') + " (%dms)", duration);
            })
    }

    bundle();
});

如果我编辑主js文件(./js/app.js),则始终检测到更改.但是,当我编辑主文件所需的其他文件时,大致每隔一段时间(但并非总是)检测到更改.我在这里做错了吗？

这是完整的Github回购,所以也许你完全了解我如何计划这个工作

我刚学习React,我正在使用ES7语法编写组件.我的想法是创建一个基本组件,它将包含一些我希望所有派生组件都具有的方法.例如,我想在没有mixin的情况下实现valueLink,以便在我的所有组件中进行双向绑定.这是我的想法:

class MyComponent extends React.Component {

    bindTwoWay(name) {
        return {
            value: this.state[name],
            requestChange: (value) => {
                this.setState({[name]: value})
            }
        }
    };
}

class TextBox extends MyComponent {
    state = {
        val: ''
    };

    render() {
        return (<div>
            <input valueLink={this.bindTwoWay('val')}/>
            <div>You typed: {this.state.val}</div>
        </div>)
    }
}

它工作得很好.但是,我无法找到有关此方法的更多信息.这不是关于valueLink,这只是一个例子.我们的想法是在基础组件中包含一些方法,然后扩展该组件,以便派生组件具有所有这些方法,就像通常的OOP方式一样.所以我想知道这是完全没问题,还是有一些我不知道的缺陷.谢谢.

我只是很好奇,我想知道这里发生了什么:

class Test
{
char * name;
public:
Test(char * c) : name(c){}
};

1)为什么Test(const char * c) : name(c){}不起作用？因为char * name不是常量？但是这个怎么样:

main(){
char * name = "Peter";
}

name是char*,但是"Peter"const char*,对吗？那么初始化是如何工作的呢？

2)Test(char * c) : name(c){ c[0] = 'a'; }- 这会导致程序崩溃.为什么？

对不起我的无知.

我无法理解同步关键字。据我所知，它用于确保只有一个线程可以同时访问同步方法/块。那么，如果只有一个线程调用某些方法，有时是否有理由使它们同步？