小编Mat*_*son的帖子

我有一个自定义堆栈类.这里可以看到大多数代码:
模板化类的成员函数,它将模板类型作为参数

我这样填充堆栈:

stack <int> Astack;
Astack.Push(1); Astack.Push(2); Astack.Push(3); Astack.Push(4);

然后我这样做:

cout << Astack.Pop() << Astack.Pop() << Astack.Pop() << Astack.Pop() <<endl;

得到这个:1234
然而,如果我这样做:

cout << Astack.Pop(); cout << Astack.Pop(); cout << Astack.Pop(); cout << Astack.Pop();

我明白了:4321,这显然是我想要的.

那么,是什么给出的？

我经常遇到一种情况,我想打印一个二维数组到屏幕或文件.我的标准方法是:

for(int q=0; q<x; q++)
{
    cout << "\n";
    for(int w=0; w<y; w++)
        cout << number[q][w] << "\t";
}

然而,当number长度变化的元件时,这通常导致柱未正确对准.如何在每个数字之后(或之前)添加正确数量的空格以使列对齐？

如果表达式计算多个&&运算符,并且不计算任何较低优先级的运算符(例如||,?:),那么只要其中一个&&s返回0,表达式是否会计算为0,还是会完成对剩余&&s的计算？

例如,

q=0; w=1; e=1; r=1;
if(q && w && r && e) {}

if()一旦q && w评估为0,这将评估为false (因为&&无论右手操作符如何,其余的必须全部评估为0)？

我有一些代码和一个数组,每次迭代我删除第一个元素,在末尾添加一个元素,然后对数组的内容求和.当然,阵列保持相同的大小.我尝试过使用矢量和列表,但两者看起来都很慢.

int length = 400;

vector <int> v_int(length, z);
list <int>   l_int(length, z);

for(int q=0; q < x; q++)
{
    int sum =0;

    if(y)                       //if using vector
    {      
        v_int.erase(v_int.begin());    //takes `length` amount of time to shift memory
        v_int.push_back(z);   
        for(int w=0; w < v_int.size(); w++)
            sum += v_int[w];
    }      
    else                        //if using list
    {
        l_int.pop_front();             //constant time
        l_int.push_back(z);
        list<int>::iterator it;
        for ( it=l_int.begin() ; it != l_int.end(); it++ ) //seems to take much  
            sum += *it;                                    //longer than vector does
    } …

我有一个程序,每次迭代需要运行M次函数,并且这些运行可以并行化.可以说我一次只能运行N个线程(比如可用的核心数).我需要一个算法,将确保我始终运行N个线程(只要剩余线程的数量N> =)和算法需要是不变的这些线程的完成顺序.此外,线程调度算法不应占用大量CPU时间.

我有类似以下的东西,但它显然有缺陷.

#include <iostream>
#include <pthread.h>
#include <cstdlib>

void *find_num(void* arg)
{
    double num = rand();
    for(double q=0; 1; q++)
        if(num == q)
        {
            std::cout << "\n--";
            return 0;
        }
}


int main ()
{
    srand(0);

    const int N = 2;
    pthread_t threads [N];
    for(int q=0; q<N; q++)
        pthread_create(&threads [q], NULL, find_num, NULL);

    int M = 30;
    int launched=N;
    int finnished=0;
    while(1)
    {
        for(int w=0; w<N; w++)
        {
            //inefficient if `threads [1]` done before `threads [2]`
            pthread_join( threads [w], …

是否可以调用std::sort()上std::vector的,我们可以指定哪些成员将被用来比较的对象这样的对象,但不必实现为每个成员一个独立的比较功能.我们可以假设我们要排序的每个成员都将<定义运算符.如果没有,当我们希望能够按照许多不同的标准对对象容器进行排序时,最好的方法是什么.

#include <iostream>
#include <vector>

using namespace std;

int main () 
{
    vector <int> qwerty;
    qwerty.push_back(5);

    vector <int>* p = &qwerty;

    cout << p[0];  //error: no match for 'operator<<' in 'std::cout << * p'

}

我一般都不清楚如何使用带向量的指针,所以我很难解释为什么这不起作用.在我看来,这应该打印5屏幕.

我想知道为什么我需要在这种情况下声明一个默认构造函数.首先,如果我把它遗漏,编译器是否会自动执行此操作？无论如何,我仍然不明白为什么它是必要的.此外,即使我省略'obj_B = origin.obj_B;',我也会收到错误.

class B
{
public:
    bool theArray[5] ;

    B(bool x) {theArray[1] = x;};
    //B(){};    
};

class A
{
public:
    B obj_B;

    A() : obj_B(1) {};
    A(A const &origin) {obj_B = origin.obj_B;}; //error:no matching function for call 
                                                      //to B::B()
}; 

int main () 
{
    std::vector <A> someAs;
    for(int q=0;q<10;q++)
        someAs.push_back(A());

    for(int q=0;q<10;q++)
        std::cout << someAs[q].obj_B.theArray[1] << std::endl;
}

我有一个表达

x += y;

并且,基于布尔值,我希望能够将其更改为

x -= y;

我当然能做到

if(i){x+=y;} else{x-=y;}
//or
x+=(y*sign);  //where sign is either 1 or -1

但如果我必须迭代地执行此操作,我想避免额外的计算.有更有效的方法吗？可以调节操作员吗？

#include <semaphore.h>

sem_t* x;

int main () 
{
    x = sem_open("x", O_CREAT, 0, 0);;
    sem_wait(x); sem_wait(x); sem_wait(x);
    std::cout << "\ndone\n";
}

这段代码甚至不应该通过第一个sem_wait()，但在我的系统上它到达了main(). 我读过的所有内容，例如这里和这里，都说，虽然Mac OS X不支持sem_init()，但它确实支持sem_open()。然而，sem_open()按照上面的使用方法并没有解决问题。我运行的是 OS X 10.5.7。

编译下面的代码g++ main.cpp functions.cpp -o run给我错误error: ‘vector’ does not name a type.在顶部声明命名空间main.cpp通常适用于所有.cpp文件.

main.cpp中

using namespace std;

#include "functions.h"

main () {}

functions.h

#include <vector>

functions.cpp

#include "functions.h"
vector <int> x;

编辑:我很欣赏所有响应者都知道他们在谈论什么,但这通常对我有用.使用makefile会对此产生影响吗？我可能会遗漏的其他东西？