小编cpp*_*der的帖子

我正在尝试编写用于STL算法的谓词函数.我看到它们是两种定义谓词的方法:

(1)使用如下简单的功能:

bool isEven(unsigned int i)   
{ return (i%2 == 0); }

std::find_if(itBegin, itEnd, isEven); 

(2)使用operator()函数如下:

class checker {  
public:  
  bool operator()(unsigned int i)  
  { return (i%2 == 0); }  
}; 

std::find_if(itBegin, itEnd, checker); 

我更多地使用第二种类型,因为我通常想创建一个谓词对象,其中包含一些成员并在算法中使用它们.当我在checker中添加相同的isEven函数并将其用作谓词时,我收到一个错误:
3.语法,它给出了错误:

class checker { 
    public: 
       bool isEven(unsigned int i) 
       { return (i%2 == 0); }
}; 

checker c; 
std::find_if(itBegin, itEnd, c.isEven); 

调用c.isEven会在编译期间发出错误,指出对某些函数的未定义引用.有人可以解释为什么3.给出错误？此外,我将不胜感激任何关于谓词和迭代器基础知识的指针.

我设法集成了boost Iostream API来读取压缩文件.我按照boost页面中的文档进行操作,并提供以下代码:

std::stringstream outStr;  
ifstream file("file.gz", ios_base::in | ios_base::binary);  
try {  
    boost::iostreams::filtering_istreambuf in;  
    in.push(boost::iostreams::gzip_decompressor());  
    in.push(file);  
    boost::iostreams::copy(in, outStr);  
}  
catch(const boost::iostreams::gzip_error& exception) {  
    int error = exception.error();  
    if (error == boost::iostreams::gzip::zlib_error) {  
       //check for all error code    
    }   
}  

代码工作正常(所以请忽略任何拼写错误.以及上面的错误:)).

1. 看起来上面的代码将读取完整的文件并在创建filtering_istreambuf时将其存储在内存中.这是真的吗,从我的调查看起来对我来说如此？如果文件被读入内存,这个代码可能是大文件的问题(这正是我正在处理的).
2. 我当前的代码从zlib逐行使用gzgets API读取gzip.有没有办法使用boost API逐行阅读？

我的程序中有一个辅助类,它在我的程序的不同类中使用了许多静态函数.例如

helper.h:

Class helper {
 public: 
   static void fn1 () 
   { /* defined in header itself */ }

   /* fn2 defined in src file helper.cpp */
   static void fn2(); 
}

Helper只有静态成员函数.因此,其他模块不会创建任何辅助对象.辅助函数用于其他模块,如:

A.cpp

#include "helper.h"
A::foo() {
  helper::fn1(); 
  helper::fn2();
}

B.cpp

#include "helper.h"
B::foo() {
  helper::fn1();
  helper::fn2(); 
}

编译器是否在A.cpp和中创建了辅助函数的单独副本B.cpp？我读了一些早期的帖子,我从编译器将创建的回复中收集到了.但是,当我打印的地址fn1,并fn2作为printf("Address of fn1 is %p\n", &helper::fn1);与printf("Address of fn1 is %p\n", &helper::fn1);来自A.cpp和B.cpp,我得到了相同的地址.我现在很困惑.有人可以澄清,如果我错过了什么.

我担心辅助函数的多个副本(如果它发生)的原因是我们正在尝试减少我们的可执行文件大小并希望优化它.

我正在编写一个实用程序函数,它将获取元素的向量(可以是string,int,double,char)并连接成一个字符串并返回它.它看起来像这样:

template<typename T>
std::string convert2Str(std::vector<T> const& vec) 
{
   std::ostringstream sStream; 
   for (size_t k=0; k<vec.size(); ++k) {
      sStream << vec[k] << " "; 
   }
   return sStream.str(); 
}

我想使这个功能更通用:

• 首先使用迭代器而不是使用索引vector<T>.我std::vector<T>::const_iterator it = vec.begin()在循环之前尝试了这个 并且编译器给了我一个错误:: error:;在它之前预期当我改变上面的定义时std::vector<std::string>::const_iterator it = vec.begin(),错误就消失了.所以,看起来我没有遵循正确的语法,请让我知道它是什么
• 其次是通过使第一个参数容器独立来使函数更通用.鉴于任何容器(vector,list,queue,deque,等),我想要做上述同样的事情.我尝试在stackoverflow中搜索这个并没有找到满意的答案.

我看到了这个讨论 - 在C++中检查一个空对象,我很惊讶没有人谈论何时引用可以指向一个null对象.在我们的代码中,我们经常使用null对象.有如下函数返回nullObj.

const Obj&  
nullObj()  
{  
   static obj* nullPtr = NULL;   
   return static_cast<  const Obj&>(*nullPtr);    
}  

实际上,当我再次查看代码以提出这个主题时,我对上面的代码如何工作有一些疑问:

1. 怎么可能这样做*nullPtr- 是不是因为nullPtr是一个静态对象,它在堆上分配内存,因此保证有一些空间和

2. 由于我们返回对obj的const引用,编译器是否创建了一个临时对象(某种类型的nullObj ??)或者const引用是否作为nullPtr本身的别名？

我有一个类，它有一个以指针作为其成员之一的结构。

struct group {
   void *v1, 
   void *v2;
};


class A {
  A (group& handle) 
  : m_handle(handle)
 private :
   group m_handle;
};

类 A 中没有指针成员。当 A 中没有定义析构函数时，我没有看到任何问题（例如内存泄漏）。我了解到，当对象 A 超出范围时，将调用 A 的析构函数，如果存在是 A 中存在的成员类，然后调用它们的析构函数，依此类推。那么，上面的 m_handle 这样的成员结构会发生什么 - 它们是否有类似于析构函数的东西，以及当对象 A 超出范围时，结构组中的两个 void 指针如何被删除？

我有一个带有声明为static的容器的类:

class test {

public: 
  test(const ClassA& aRef, const std::string& token); 
  test(const test& src); 
  ~test();

private: 
  ClassA& m_ObjRef;
  static std::vector<std::string> s_toks; 
};

s_toks容器在test.cpp中定义的构造函数中初始化如下:

std::vector<std::string> test::s_toks; 

    test::test(const ClassA& aRef, const std::string& token) 
       : m_ObjRef(aRef)
    {
       my_tokenize_function(token, s_toks);
    }

    test::test(const test& src)
       : m_ObjRef(src.m_ObjRef)
    {   
       /* What happens to s_toks; */
    }

如果我不复制s_toks,并且从新复制的对象访问s_toks,则它为空.处理这个问题的正确方法是什么？

我正在编写一个批处理脚本来从文件中读取.该文件包含诸如token = value之类的行.我有代码来解析文件的每一行,它存储在%% i中.以下代码尝试提取令牌的值:

请注意,此脚本正在使用延迟扩展,如评论中所述.

   for /f "tokens=1* delims==" %%a in ("%%i") do (  
      if "%%a"=="password" ( set password=%%b )  
   )

如果令牌密码的值包含"!",那么"!" 被跳过,只有其余的字符串存储在变量密码中.例如,如果该行是:

密码=测试!

然后变量密码=测试.我试图以各种方式更改输入文件,批处理脚本读取除"!"之外的所有内容.我用过:

1. 密码="测试!"
2. 密码= "测试^!"

3. 密码=测试%!

   密码=测试%!

一切都跳过"!".知道如何用"!"读取字符串 变成一个变量？

我正在使用用C编写的库,并且该库提供了仅使用void*的头文件.该库用于创建一种图形,该图形存储在C数据库中.标头将void*返回到图中的节点.要创建图形,我需要解析一堆节点名称.与节点名称堆栈并行,我需要为节点维护堆栈void*.我有这样的事情:

std::stack < void* > nodeStack;   
while (!nodeNameStack.empty()) {  
   // check if nodeNamestack.front() meets some criteria 
   nodeStack.push(C_API_To_Create_Node(nodeNameStack.pop()));

   // Do some processing  
   // check if nodeStack.size() >= 2  
   void *node1 = nodeStack.pop()  
   void *node2 = nodeStack.pop()  
   // Above line issues error saying void value not ignored as it ought to be.. 

我不确定是什么问题,因为我们保证nodeStack大小至少为2.我会很感激任何克服此错误的建议.

我正在为FILE*编写RAII包装器.我注意到,当在析构函数中关闭后删除FILE*会导致未定义的行为(seg.错误或其他地方的错误).我假设fclose会将FILE*设置为NULL,但事实并非如此.

class smartFP {
  smartFP (const std::string& name) 
  : fp (fopen(name.c_str(), "r")
  { }

  ~smartFP()
  { 
     if (fp) {
        fclose(fp); 
        // delete(fp); <- This is causing crash
        fp = NULL; <- Is this OK?
     }
  }

private:
   FILE *fp;
};

• 为什么fclose没有将FILE*设置为NULL？
• 第二个问题是fopen在堆或堆栈中为fp分配内存吗？我认为它在堆上做了,因此想在fclose之后进行删除,这样fp的堆上的4或8个字节就被解除分配了.但看起来这不是必需的.