小编Abh*_*yal的帖子

在css/libsass的帮助下,我在文件夹中生成了一堆不同的css文件.此外,我确实normalize.css已经放在css/文件夹中,以允许在所有浏览器中规范化CSS.我使用npm作为构建工具,我的内容package.json如下:

{
.....
"scripts": {
    "test": "npm run lint",
    "lint": "csslint css/*.css",
    "build": "node-sass sass/ -o css/",
    "postbuild": "cat css/*.css | cleancss -o css/main.min.css"
  },
.....
}

但是在构建后的步骤中,normalize.css文件的内容应该在任何其他css文件内容之前,但行为是不一致的.我需要确保规范化的东西比所有其他css文件提前,任何抬头都会有所帮助.

Tldr - 串联css文件的串联导致normalize.css被追加到中间或最后.我在连接的css文件的开头需要它.

谢谢.

为什么 using 会vector.erase(vector.end())产生

Segmentation fault (core dumped)

使用此代码时：

#include <iostream>
#include <vector>
using namespace std;

void printMe(vector<int>& v){ for(auto &i:v) cout<<i<<" "; cout<<"\n"; }

int main() {
    vector<int> c = { 1,2,3,4,5,6,7,8};
    printMe(c);
    c.erase(c.begin());
    printMe(c);
    c.erase(c.begin());
    printMe(c);
    // c.erase(c.end()); //will produce segmentation fault
    // printMe(c);
    return 0;
}

我对这些迭代器有点陌生，所以这让我措手不及。虽然我知道存在vector.pop_back()。我很想知道到底是什么原因造成的。

程序的链接。

我正在实现Kruskal算法,这是一种众所周知的方法来查找加权图的最小生成树.但是,我正在调整它以在图表中查找周期.这是Kruskal算法的伪代码:

KRUSKAL(G):
1 A = ?
2 foreach v ? G.V:
3    MAKE-SET(v)
4 foreach (u, v) ordered by weight(u, v), increasing:
5    if FIND-SET(u) ? FIND-SET(v):
6       A = A ? {(u, v)}
7       UNION(u, v)
8 return A

我有一个很难把握FIND-SET()和MAKE-SET()功能,或者它们与并查集的实现.

我当前的代码如下所示:

class edge {
    public:      //for quick access (temp) 
      char leftV;
      char rightV;
      int weight;
};

std::vector<edge> kruskalMST(std::vector<edge> edgeList){
    std::vector<char> set;
    std::vector<edge> result;
    sortList(edgeList);    //sorts according to weight ( passed by reference)
    do{
        if(set.empty()){
            set.push_pack(edgeList[i].leftV); …

请考虑以下代码示例:

#include <vector>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <functional>

int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Among the numbers: ";
    std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';

    if (std::all_of(v.cbegin(), v.cend(), [](int i){ return i % 2 == 0; })) {
        std::cout << "All numbers are even\n";
    }
    if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus<int>(), 
                                                     std::placeholders::_1, 2))) {
        std::cout << "None of them are odd\n";
    }
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : …

考虑以下代码,我正在尝试引入默认构造函数以及参数化构造函数class A.这种方式是在最近的c ++改进中引入的.

class A  {
    private:
        unsigned int count;

    public:
        A(int new_c) : count(new_c) {}
        A() : A(10) {}
};

vs在参数化构造函数上设置默认参数并完全忽略默认构造函数的旧方法.

class A  {
    private:
        unsigned int count;

    public:
        A(int new_c = 5) : count(new_c) {}
};

除了遵循现代惯例之外,使用第一种方法比第二种方法有什么优势吗？

这是我在codereview 上发布的问题的后续内容- 终端上的彩色输出,我试图在终端上输出彩色字符串并通过isatty()调用检测它.然而,@ Jerry Coffin指出 -

您使用isatty来检查标准输出是否连接到终端,无论您要写入哪个流.这意味着如果您std::cout作为要写入的流传递,其余功能只能正常工作.否则,您可能在写入非TTY的内容时允许格式化,并且在写入TTY内容时可能禁止格式化.

这是我不知道的事情(读作没有经验)我甚至不知道cin/cout可以重定向到别处的事实.所以我试着阅读更多关于它的内容,并在SO上发现了一些现有的问题.这是我一起入侵的内容:

// initialize them at start of program - mandatory

std::streambuf const *coutbuf = std::cout.rdbuf();
std::streambuf const *cerrbuf = std::cerr.rdbuf();
std::streambuf const *clogbuf = std::clog.rdbuf();


// ignore this, just checks for TERM env var

inline bool supportsColor()
    {
        if(const char *env_p = std::getenv("TERM")) {
            const char *const term[8] = {
                "xterm", "xterm-256", "xterm-256color", "vt100",
                "color", "ansi",      "cygwin",         "linux"};
            for(unsigned int …

我有一个当前为不同数据类型重载的函数,并使用lambda(函数指针)初始化这些数据类型.我正在将它们转换为模板实例但尚未成功.

这是重载版本 -

#include <iostream>
using namespace std;


void doSome(int (*func)(int &)){
    int a;
    a = 5;
    int res = func(a);
    cout << a << "\n";
}


void doSome(int (*func)(double &)){
    double a;
    a = 5.2;
    int res = func(a);
    cout << a << "\n";
}


int main() {
    doSome([](int &a){
        a += 2;
        return 1;
    });

    doSome([](double &a){
        a += 2.5;
        return 1;
    });
    return 0;
}

请注意,我已经采用了示例int并且double为了简化,它们可能是实际代码中的一些完全不同(和复杂)类型.

这是我尝试过的 -

#include <iostream>
using namespace std; …

我有以下虚拟代码:

 #include <iostream>
 #include <vector>

 using namespace std;

 class Parent {
 public:
     void printHello() {
         cout << "Hello Parent" << endl;
     }
 };

 class Child : public Parent {
 public:
     void printHello() {
         cout << "Hello Child" << endl;
     }
 };


 int main() {
     vector<Parent*> list;
     Child child;
     list.push_back(&child);

     list[0]->printHello();
  }

  Output: Hello Parent

我正在尝试创建从父类派生的类的对象列表.迭代它们并运行一个方法,它们都继承并覆盖.

我假设子类中的方法会覆盖父类中的方法.

我也试过用vector<Parent>而不是用的方法vector<Parent*>.

结果是一样的.如何调用派生类的方法而不是父类？

我有一个访问(读取和写入)std::atomic<bool>变量的函数.我试图理解指令的执行顺序,以便决定原子是否足够,或者我将在这里使用互斥.功能如下 -

// somewhere member var 'executing' is defined as std::atomic<bool>`

int A::something(){

    int result = 0;
    // my intention is only one thread should enter next block
    // others should just return 0
    if(!executing){
        executing = true;

        ...
        // do some really long processing
        ...

        result    = processed;
        executing = false;
    }

    return result;
}

我在cppreference上看过这个页面,提到 -

std :: atomic模板的每个实例化和完全特化都定义了一个原子类型.如果一个线程写入原子对象而另一个线程从中读取,则行为是明确定义的(有关数据争用的详细信息,请参阅内存模型)

在内存模型页面上提到以下内容 -

当表达式的评估写入内存位置而另一个评估读取或修改相同的内存位置时,表达式会发生冲突.具有两个冲突评估的程序具有数据竞争,除非两者之一

• 两个冲突的评估都是原子操作(参见std :: atomic)

• 其中一个冲突的评估发生在另一个之前(参见std :: memory_order)

如果发生数据争用,则程序的行为未定义.

略低于它读 -

当线程从内存位置读取值时,它可能会看到初始值,写在同一线程中的值或写在另一个线程中的值.有关从线程写入的命令对其他线程可见的顺序的详细信息,请参阅std …

考虑以下代码 -

#include <algorithm>
#include <iostream>
#include <vector>

int main()
{

    std::vector<int> d {100, 200, 300};
    std::vector<int> l {1, 2, 3, 4, 5};

    std::move(d.begin(), d.end(), std::inserter(l, l.begin()));

    for (int n : l) std::cout << n << ' ';
    std::cout << '\n';
    for (int n : d) std::cout << n << ' ';
    std::cout << '\n\n';


    for (int &n : d) n +=5;

    for (int n : l) std::cout << n << ' ';
    std::cout << '\n';
    for (int n : …