小编ano*_*ous的帖子

我正在尝试使用gcc编译一个早期使用SunStudio的项目,并在以下代码中收到错误:

ostream & operator << ( ostream & os, const UtlDuration & d )
{
    if ( d._nsec == 0 )
    {
        os << d._sec << " sec";
        return os;
    }
    else
    {
        cout.fill( '0' );
                os << d._sec << "." << std::setw(9) << d._nsec << " sec";
        cout.fill( ' ' );
        return os;
    }
}

错误:"setw"不是"std"的成员

我无法解决此错误,有人请解释这个错误背后的原因

我读到模板copy-con永远不是默认的onstructor,而模板赋值操作永远不是复制赋值操作符.

我无法理解为什么需要这个限制并立即上线到ideone并返回一个测试程序但是这里复制构造函数永远不会被调用进一步的谷歌搜索我遇到了模板化的构造函数并尝试了但仍然从未调用复制构造函数.

#include <iostream>
using namespace std;

template <typename T> class tt
{
    public :
    tt()
    {
        std::cout << std::endl << "   CONSTRUCTOR" << std::endl;
    }
    template <typename U> const tt<T>& operator=(const tt<U>& that){std::cout << std::endl << "   OPERATOR" << std::endl;}
    template <typename U> tt(const tt<U>& that)
    {
        std::cout << std::endl << "    COPY CONSTRUCTOR" << std::endl;
    }
};


tt<int> test(void)
{
    std::cout << std::endl << "      INSIDE " << std::endl; tt<int> a; return a;
}

int main() …

我检查了protected访问说明符可以在里面使用class,struct以及union.我知道protected访问说明符意味着成员将是私有的,但对派生类是可见的.我无法想到一个合理的用例,其中protectedunion 中的关键字很有用,因为union不能是继承层次结构的一部分.既然在联盟中private并protected没有任何区别,为什么还允许protected内部工会呢？

我知道C++实现了虚拟函数的运行时多态性,虚拟关键字是继承的,但我没有看到在派生类中使用虚拟关键字.

例如,在下面的情况下,即使你在派生类中删除虚拟关键字仍然ptr-> method()调用转到derived :: method.那么这个虚拟关键字在派生类中做了多少额外的事情？

#include<iostream>

using namespace std;

class base
{
public:
    virtual void method()
    {
        std::cout << std::endl << "BASE" << std::endl;
    }
};

class derived: public base
{
public:
    virtual void method()
    {
        std::cout << std::endl << "DERIVED" << std::endl;
    }
};

int main()
{
    base* ptr = new derived();
    ptr->method();
    return 9;
}

我得到了这个问题的考试:

给定整数数组,使用O(N)时间复杂度和O(1)空间复杂度找到第一个不在数组中重复的数字.

我想不出任何解决方案.我知道我可以迭代数组并维护一个linkedhashmap,它将存储数组元素和它出现的次数,然后最后我必须搜索hashmap来找到那个数字.空间复杂度大于O(1)但我想不出其他解决方案.

我也仔细阅读问题,并说数组的最大尺寸为100万.我认为如果我们可以创建一个自定义散列图,它将使用100万大小的固定大小的数组,那么这可以在O(1)空间复杂度中实现,因为在这种情况下,所需的存储将是恒定的,但如果我是正确的则不确定.如果有任何其他解决方案,请告诉我.

我在一份试卷中解决了这个问题，并在答案书中找到了一个解决方案。我无法理解其背后的算法。谁能解释一下这个算法是如何工作的？

给定 n 个非负整数表示海拔图，其中每个条形的宽度为 1，计算下雨后它能够捕获多少水。

例如，给定输入

[0,1,0,2,1,0,1,3,2,1,2,1] 

返回值将是

6

根据答案书的解决方案是这样的

public class Solution {
    public int trap(int[] height) {
        if (height.length <=2 )
            return 0;
        int h = 0, sum = 0, i = 0, j = height.length - 1;
        while(i < j)
        {
            if ( height[i] < height[j] )
            {
                h = Math.max(h,height[i]);
                sum += h - height[i];
                i++;
            }
            else
            {   
                h = Math.max(h,height[j]);
                sum += h - height[j];
                j--;
            }
        }
        return sum;
    }
}

谢谢

我只是问一个由于好奇而出现的一般性问题,当我在一个库项目中工作时,在另一个方法中抛出异常的返回值,但我想将该异常转换为返回值.我使用多个try catch块解决了它,但只是想知道在抛出异常后C++中是否有一种方法可以恢复.

我有一个关于使用 pthread 条件变量的问题。一般用例是这样的

//thread 1:
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
do_something()
pthread_mutex_unlock(&mutex);

//thread 2:
pthread_cond_signal(&cond);  

现在我知道 pthead_cond_wait 将解锁互斥体并进入睡眠状态，唤醒时它将锁定互斥体，然后从调用返回，但如何确保线程 1 处于条件等待状态后来自线程 2 的信号到达线程 1。可能会出现线程 2 先运行然后线程 1 导致唤醒丢失的情况。

如果我再次在线程 2 中使用互斥锁，那么线程 2 也可能会获得锁，它会发出信号，而线程 1 仍在尝试获取锁。这将再次导致唤醒丢失。

如何确保来自条件变量的信号到达等待该信号的线程？

谢谢

我有两个非常大的整数数组,每个数组的大小约为100万.我必须找到两个数组中都存在的第一个整数.

我尝试用套装做到这一点.

(1)同时遍历每个数组并将两个数组的元素插入集合中.

(2)每当集合拒绝接受这是第一个交叉点.

int Solution(int A[], int B[])
{
    Set s = new HashSet();
    for (int i = 0 ; ; i++)
    {
        if ( i < A.length )
        {
            if( !s.Add(A[i]) )
                System.out.println(A[i]);
        }
        if ( i < B.length )
        {
            if( !s.Add(B[i]) )
                System.out.println(B[i]);
        }
    }
}

我们能否改进此解决方案以减少时间复杂度？

谢谢

我们可以在匿名类中声明枚举吗？

我写了一个示例程序,令人惊讶的是一个空的枚举,在匿名类编译中没有任何枚举常量,但枚举常量枚举不会.

程序下面给出了错误信息

Main.java:16:错误:非静态变量,这不能从静态上下文obj.no引用(new a(){enum e {j}});

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class a {}
class Ideone
{
    public void no(a arg) {;} ;
    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
        Ideone obj = new Ideone();
        obj.no(new a() { enum e{j,k;} });


    }
}

如果我删除枚举常量j和k,程序编译.

我不理解这种行为背后的理性.由于enum类是隐式静态的,因此不应该允许在匿名或本地类中使用,但是在这里它只允许空的枚举类.