小编Cha*_*had的帖子

使用std::map或时std::unordered_map,访问可能不在容器中的元素的首选方法是什么？如果有人请求许可或要求宽恕吗？为什么？

那是,

if (mymap.find(key) != mymap.end()) {
    value = mymap.at(key);
    // do stuff
}
else {
    // do something else
}

与

try {
    value = mymap.at(key);
    // do stuff
}
catch(const std::out_of_range& oor) {
    // do something else
}

我有一个应用程序,它被编写为boost::asio专门用作输入数据源,因为我们的大多数对象都是基于网络通信的.由于某些特定要求,我们现在还要求使用共享内存作为输入方法.我已经编写了共享内存组件,它的工作相对较好.

问题是如何处理从共享内存进程到消费应用程序的通知,数据可供读取 - 我们需要处理现有输入线程中的数据(使用boost::asio),我们还需要不阻止该输入线程等待数据.

我通过引入一个中间线程来实现这一点,该线程等待从共享内存提供程序进程发出信号的事件,然后将完成处理程序发布到输入线程以处理数据中的读取.

现在这也正常工作,但是中间线程的引入意味着在大量的情况下我们有一个额外的上下文切换,然后我们才能读取对延迟有负面影响的数据,并且附加线程的开销也是相对昂贵.

这是应用程序正在做的简单示例:

#include <iostream>
using namespace std;

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/bind.hpp>

class simple_thread
{
public:
   simple_thread(const std::string& name)
      : name_(name)
   {}

   void start()
   {
      thread_.reset(new boost::thread(
         boost::bind(&simple_thread::run, this)));
   }

private:
   virtual void do_run() = 0;

   void run()
   {
      cout << "Started " << name_ << " thread as: " << thread_->get_id() << "\n";
      do_run();
   }


protected:
   boost::scoped_ptr<boost::thread> thread_;
   std::string name_;
};

class input_thread
   : public simple_thread
{ …

我一直在使用visual studio 2012控制台模式进行C++项目,并且我一直在使用该cin函数获得这个奇怪的持久性错误.

根据>>我得到一条红线,程序告诉我no operator matches these operands.我已经在一个单独的方法中初始化了所有数组元素.

这是一个片段示例(实际代码包含更多变量):

for (int i = 0; i < 14; i++)
{
    cout << "For taxi: " << i+1 << "Please input the taxi rank they are currently parked at, if at all ('Train Station', 'South Walls' or 'Chell Road')" << endl;
    cin >> allTaxiDetails[i].taxiRank;
}

allTaxiDetails是一个数组类型" taxiDetails" 的数组,这是这个结构:

struct taxiDetails { 
    string taxiDriverSurname; 
    int taxiID; 
    int taxiCoordinates; 
    int numberOfSeats; 
    bool taxiContainsCustomerYesNo; 
    bool WheelChairAccessibleVehicle; 
    string …

我已经实现了一个线程池使用boost::asio,以及一些数字boost::thread对象调用boost::asio::io_service::run().但是,我得到的一个要求是有办法监视所有线程的"健康".我的目的是创建一个可以通过线程池传递的简单的sentinel对象 - 如果它通过,那么我们可以假设该线程仍在处理工作.

但是,鉴于我的实现,我不确定如何(如果)我可以可靠地监视池中的所有线程.我只是将线程函数委托给了boost::asio::io_service::run(),所以将一个sentinel对象发布到io_service实例中并不能保证哪个线程实际上会获得该sentinel并完成工作.

一种选择可能是只是定期插入标记,并希望每个线程在一段合理的时间内至少拾取一次,但这显然不是理想的.

以下面的例子为例.由于处理程序编码的方式,在这个例子中我们可以看到每个线程将执行相同数量的工作,但实际上我将无法控制处理程序实现,一些可以长时间运行而其他人将几乎即时.

#include <iostream>
#include <boost/asio.hpp>
#include <vector>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

void handler()
{
   std::cout << boost::this_thread::get_id() << "\n";
   boost::this_thread::sleep(boost::posix_time::milliseconds(100));
}

int main(int argc, char **argv)
{
   boost::asio::io_service svc(3);

   std::unique_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(svc));

   boost::thread one(boost::bind(&boost::asio::io_service::run, &svc));
   boost::thread two(boost::bind(&boost::asio::io_service::run, &svc));
   boost::thread three(boost::bind(&boost::asio::io_service::run, &svc));

   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);
   svc.post(handler);

   work.reset();

   three.join();
   two.join();
   one.join();

   return 0;
}

我们有一个160+项目的VS2010 C++解决方案.我从一个完全空的输出目录和"Build Solution"开始.我将IDE构建详细程度设置为Normal.在构建过程中,我会看到"输出"窗口.(VS2010设置为一次构建2个项目,每次只编译1个.cpp文件.)

大多数项目显示编译器(每个.cpp文件名)和库管理器/链接器的大量输出行.

但是 - 一些项目(最近一次运行中的10项)显示出极低的输出.例:

29>------ Build started: Project: DebuggingService (LHFramework\DebuggingService\DebuggingService), Configuration: Debug x64 ------
29>Build started 8/17/2011 3:23:24 PM.
29>
29>Build succeeded.
29>
29>Time Elapsed 00:00:00

显示这些症状的项目未被禁用,它们有许多.cpp文件,以及由此版本生成的相应结果文件(.obj,.lib,.exe等).

当我清空构建输出目录并从头开始重新运行构建时,一组不同的项目可能会显示这些症状!

似乎那些项目构建=正在发生(显然超过00:00:00),但跳过了"输出"窗口中的显示.我不知道任何影响构建输出的项目设置:我认为它只受IDE级别设置的控制.在任何情况下,我们对所有项目使用相同的设置,因此它们都应显示相同级别的输出细节.

.log文件只包含上面输出的最后五行,减去前导"29>"指示符.创建了各种.tlog文件:3个来自"cl",3个来自"custombuild",3个来自"lib".我几乎可以弄明白他们的意思.:)

可能重要注意:我们的.sln/.vcxproj/etc文件由CMake生成.我没有设置它,但所有项目都有一个自定义构建步骤来运行CMake来确定需要完成哪些工作(编译/链接/等).

那么......这是VS2010的已知问题吗？或者我们偶然发现了一些VS2010 < - > CMake互动？

麦克风

我有多年的 Java 开发经验，现在我想切换到 C++，我很难理解内存管理系统。

让我用一个小例子来说明情况：

根据我的理解，您可以在堆栈或堆上分配空间。第一个是通过声明这样的变量来完成的：

 int a[5]

或者

int size = 10;
int a[size]

相反，如果要在堆上分配内存，则可以使用“new”命令来完成。例如像：

int *a = new int[10]; (notice that I haven't tried all the code, so the syntax might be wrong)

两者之间的一个区别是，如果它在函数完成时分配在堆栈上，那么空间会自动释放，而在另一种情况下，我们必须使用 delete() 显式释放它。

现在，假设我有一个这样的类：

class A {
  const int *elements[10];

  public void method(const int** elements) {
    int subarray[10];
    //do something
    elements[0] = subarray;
  }
}

现在，我有几个问题：

1. 在这种情况下，子数组在堆栈上分配。为什么函数方法执行完后，查看elements[0]还是看到子数组的数据？编译器是否翻译了堆分配中的第一个分配（在这种情况下，这是一个好习惯）？
2. 如果我将子数组声明为“const”，则编译器不允许我将其分配给元素。为什么不？我认为 const 只涉及无法更改指针，但没有其他问题。
3. （这可能很愚蠢）假设我想分配的“元素”不是固定的 10 个元素，而是来自构造函数的参数。是否仍然可以在堆栈中分配它，或者构造函数将始终在堆中分配它？

抱歉提出这样的问题（这对于 C 专家程序员来说可能看起来很愚蠢），但是 C++ 的内存管理系统与 Java 非常不同，我想避免泄漏或代码缓慢。提前谢谢了！

在boost::asio对文件async_receive(),它支持国家"接收到一次过多个缓冲区",而我可以编写这个我不能真正看到如何(或者)它的工作原理.

我们的情况是,我们的某个供应商每秒向我们发送数千个UDP数据包,足以让我们看到"丢弃的数据包"在某些情况下出现峰值.

如果我们真的可以在一次async_receive()调用中填充多个缓冲区,那将是理想的,但在测试期间,似乎即使指定了多个缓冲区,也仅为一个数据报调用该处理程序.

我已经包含了我的测试代码,对不起,它是如此冗长,但我需要它灵活地监听多个接口/多播.

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/lexical_cast.hpp>
#include <memory>
#include <algorithm>
#include <vector>
#include <string>
#include <cstdint>

// configuration options...
std::string nic;
std::string mc;
uint16_t port = 0;
uint16_t buffer_size = 0;
uint32_t socket_buffer_size = 0;
uint32_t scat_cnt = 1;

// The raw data buffer
std::vector<uint8_t> buffer;

// The scatter/gather buffer
std::vector<boost::asio::mutable_buffer> gather_buffer;

boost::asio::io_service svc;
std::unique_ptr<boost::asio::ip::udp::socket> socket_;

size_t messages_received = 0;
size_t bytes_received = 0;

bool parse_command_line(std::vector<std::string> command_line);

void …

我从C++中的一个函数调用一个函数,该函数的getline(cin,name)名称是一个字符串.第一次循环,程序不等待输入.它将在所有其他通过循环.有什么想法吗？

void getName (string& name)
{ 
     int nameLen; 
      do{
          cout << "Enter the last Name of the resident." << endl << endl
              << "There should not be any spaces and no more than 15"
              << " characters in the name."  << endl;



         getline(cin,name);
            cout << endl;
            nameLen = name.length();// set len to number of characters input

         cout << "last" << name << endl;
         }
      while (nameLen < LastNameLength);   
      return;
}

我正在使用类似以下代码段的内容来进行一些初始化.我知道初始化p<T>::i_是无序的.我相信这h是有序的,所以我应该能够推断出它被初始化的顺序.鉴于标题p包含在定义之前h,是否有任何保证p<T>::i_将在之前初始化h？

struct helper
{
   template <typename T>
   helper(const T&, int i)
   {
      p<T>::i_::push_back(i);
   }
};
static helper h;

类p定义如下.

template <typename T>
struct p
{
   static std::vector<int> i_;
};
template <typename T>
std::vector<int> p<T>::i_;

虽然尝试编写一个包装器shared_ptr会在支持继承类的同时隐藏用户的内存分配和释放,但我偶然发现了一些非常奇怪的错误,这些错误表明编译器在重载期间查找错误的函数,或者我对混合重载和模板的了解是错误.所以我写了这个东西用于测试:

#include <iostream>

void out(int i) {
    std::cout << i << '\n';
}

template <class T>
struct Inst {
    template <class TT>
    Inst(const TT &) {out(1);}
    Inst(const Inst &) {out(2);}
    template <class TT>
    Inst(TT &&) {out(3);}
    Inst(Inst &&) {out(4);}
    Inst() {out(-1);}
    ~Inst() {out(1000);}
};

class K {};
class KK : K {};

int main() {
    out(3000);
    K k; KK kk; Inst<K> i;
    Inst<K> I1{k};
    Inst<K> I2{kk};
    Inst<K> I3{i};
    Inst<K> I4{K()};
    Inst<K> I5{KK()};
    Inst<K> I6{Inst<K>()};
    out(2000);
}

我会合理地期望会I1 …