小编EXP*_*XP0的帖子

编辑:在实施James Hopkin的建议后,我仍然收到"无效名称'null'"的警告,这比那些怪异的角色要好得多.然后,我回去再次读取库文档,结果发现,对于该特定函数,它的参数应该有一个非NULL字符串元素而不是aNames的大小.额外的字符串有其他目的.添加一个字符串后,代码运行正常.这都是我的错,我很抱歉.

原帖:

嗨,

这是我的第一篇文章所以请你好.我在这个论坛搜索并用Google搜索,但我仍然找不到答案.这个问题困扰了我一天多,所以请给我一些帮助.谢谢.

我需要将一个字符串向量传递给库函数foo(char const*const*const).我不能传递&Vec [0],因为它是一个指向字符串的指针.因此,我有一个数组并将c_str()传递给该数组.以下是我的代码(aNames是字符串的向量):

const char* aR[aNames.size()];

std::transform(aNames.begin(), aNames.end(), aR, 
                boost::bind(&std::string::c_str, _1));
foo(aR);

但是,它似乎导致一些未定义的行为:

如果我运行上面的代码,那么函数foo会在aR中抛出一些关于非法字符('èI'blablabla)的警告.

如果我在函数foo之前打印aR,如下所示:

std::copy(aR, aR+rowNames.size(), 
          std::ostream_iterator<const char*>(std::cout, "\n"));
foo(aR);

然后,一切都很好.我的问题是:

1. 转换是否会导致未定义的行为？如果是这样,为什么？

2. 将字符串向量传递给foo(char const*const*const)的正确方法是什么？

通过使用智能指针的"三规则",我有点困惑.如果我有一个类,其唯一的数据成员是智能指针,我是否需要显式定义析构函数,复制构造函数和赋值运算符？

我的理解是,由于智能指针将自动处理资源,因此我不需要显式定义析构函数,因此我不需要根据三个规则对其他两个执行此操作.但是,我不确定默认的复制构造函数是否足以用于智能指针,例如shared_ptr.

谢谢您的帮助!

我有一个基类和几个派生类.派生类使用一些常见数据,我可以将这些常用数据作为基类的受保护成员吗？我知道受保护的成员有时会破坏封装,所以我想知道是否有任何好的方法.

这是一个具体的例子:

class Base{
public:
   virtual void foo() = 0;
   void printData();
protected:
   std::vector<std::string> mData;
}

class Dr1 : public Base{
public:
   virtual void foo(); //could change mData
}

class Dr2 : public Base{
public:
   virtual void foo(); //could change mData
}

如果我将mData作为私有成员放入Dr1和Dr2中,那么我需要将它放在两个中,并且我不能在Base中使用printData(),因为printData()需要访问mData,除非我使printData()虚拟并且Dr1和Dr2中的功能相同,这对我来说没什么意义.

有没有更好的方法来解决这个问题而不使用受保护的成员？谢谢.

在我看来,下面的代码(来自一些C++问题)应该导致UB,但它似乎不是.这是代码:

#include <iostream>
using namespace std;
class some{ public: ~some() { cout<<"some's destructor"<<endl; } };
int main() { some s; s.~some(); }

答案是:

some's destructor
some's destructor

我学习了c ++ faq lite,我们不应该显式调用析构函数.我认为在显式调用析构函数后,应该删除对象s.程序完成后会自动再次调用析构函数,它应该是UB.但是,我在g ++上尝试了它,并获得与上述答案相同的结果.

是因为这个类太简单了(不涉及新的/删除)？或者在这种情况下它根本不是UB？

这可能是一个愚蠢的问题,但我只是不确定答案.以下代码读取文件,对于文件的每一行,由"new"创建智能指针.如果将来会使用智能指针,它将存储在列表中,否则不会存储.

我的问题是:如果未存储智能指针,是否会导致潜在的内存泄漏？谢谢.

int main(){
    .....;
    std::list<SomeClass> aList;
    while(inFile >> ss){
         std::tr1::shared_ptr<SomeClass> aPtr(new SomeClass());
         //do something in foo(aPtr) to aPtr, 
         //if aPtr will be used later, then it's stored in aList
         //otherwise, it's not stored
         foo(aPtr);
    }
    .....;
}

编辑:感谢您的所有提示回复.现在我看到作业不起作用.从另一个线程我读到,Java中的迭代器比C++中的迭代器强大得多.请问为什么在Java中使用iterator？只是为了取代"for"循环？谢谢.

一些说明:

• 第二个迭代器应该从第一个迭代器的位置开始.
• 我尝试从头开始查看有序列表,在列表中找到一些具有与aItr指向的属性类似的对象.

我不介意使用两个"for"循环,但我知道Java对所有这些库都非常强大.我只是好奇是否有比两个"for"循环更好的方法.谢谢.

嗨,

我一直在使用C++,但我是Java的新手,所以请耐心等待.我尝试使用两个迭代器遍历ArrayList.第一个迭代器遍历列表,第二个迭代器从第一个迭代器指向的位置开始,一直到列表的末尾.以下代码是我想要做的(虽然可能无效):

.......; //initialize aList here ......
Iterator aItr = aList.iterator();
while(aItr.hasNext()){
     int a = aItr.next();
     Iterator bItr = aItr; //-----> is it valid? Any bad consequence?
     while (bItr.hasNext()){
         ............; //do stuff
     }
}

将一个迭代器分配给另一个迭代器是否有效？如果没有,那么做我想做的最好的方法是什么？谢谢.

我知道它在C++中有效,但对Java不确定,我搜索了很多,但所有结果都使用迭代器来打印一些东西.非常感谢您的帮助.

我试图播放一个不那么大的地图(当保存到HDFS作为文本文件时大约70 MB),我出现了内存错误.我试图将驱动程序内存增加到11G并将执行程序内存增加到11G,但仍然会出现相同的错误.memory.fraction设置为0.3,并且缓存的数据也不多(小于1G).

当地图只有大约2 MB时,没有问题.我想知道在播放对象时是否存在大小限制.如何使用更大的地图解决这个问题？谢谢!

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.IdentityHashMap.resize(IdentityHashMap.java:469)
    at java.util.IdentityHashMap.put(IdentityHashMap.java:445)
    at org.apache.spark.util.SizeEstimator$SearchState.enqueue(SizeEstimator.scala:159)
    at org.apache.spark.util.SizeEstimator$.visitArray(SizeEstimator.scala:229)
    at org.apache.spark.util.SizeEstimator$.visitSingleObject(SizeEstimator.scala:194)
    at org.apache.spark.util.SizeEstimator$.org$apache$spark$util$SizeEstimator$$estimate(SizeEstimator.scala:186)
    at org.apache.spark.util.SizeEstimator$.estimate(SizeEstimator.scala:54)
    at org.apache.spark.util.collection.SizeTracker$class.takeSample(SizeTracker.scala:78)
    at org.apache.spark.util.collection.SizeTracker$class.afterUpdate(SizeTracker.scala:70)
    at org.apache.spark.util.collection.SizeTrackingVector.$plus$eq(SizeTrackingVector.scala:31)
    at org.apache.spark.storage.MemoryStore.unrollSafely(MemoryStore.scala:278)
    at org.apache.spark.storage.MemoryStore.putIterator(MemoryStore.scala:165)
    at org.apache.spark.storage.MemoryStore.putIterator(MemoryStore.scala:143)
    at org.apache.spark.storage.BlockManager.doPut(BlockManager.scala:801)
    at org.apache.spark.storage.BlockManager.putIterator(BlockManager.scala:648)
    at org.apache.spark.storage.BlockManager.putSingle(BlockManager.scala:1006)
    at org.apache.spark.broadcast.TorrentBroadcast.writeBlocks(TorrentBroadcast.scala:99)
    at org.apache.spark.broadcast.TorrentBroadcast.<init>(TorrentBroadcast.scala:85)
    at org.apache.spark.broadcast.TorrentBroadcastFactory.newBroadcast(TorrentBroadcastFactory.scala:34)
    at org.apache.spark.broadcast.BroadcastManager.newBroadcast(BroadcastManager.scala:63)
    at org.apache.spark.SparkContext.broadcast(SparkContext.scala:1327)

编辑: 根据评论添加更多信息:

• 我使用spark-submit以客户端模式提交已编译的jar文件.Spark 1.5.0
• spark.yarn.executor.memoryOverhead 600
• set("spark.kryoserializer.buffer.max","256m")
• set("spark.speculation","true")
• set("spark.storage.memoryFraction","0.3")
• set("spark.driver.memory","15G")
• set("spark.executor.memory","11G")
• 我试过set("spar.sql.tungsten.enabled","false")并没有帮助.
• 主机有60G内存.大约30G用于Spark/Yarn.我不确定我的工作堆大小是多少,但同时还没有其他进程.特别是地图只有70MB左右.

一些与广播相关的代码:

val mappingAllLocal: Map[String, Int] = mappingAll.rdd.map(r => (r.getAs[String](0), r.getAs[Int](1))).collectAsMap().toMap
// I can …

基于"c ++ primer",静态数据成员的类型可以是它所属的类类型:

class Bar {
 public:
     // ...
 private:
     static Bar mem1; // ok
 };

但是,我很难想象这样一个功能有用的场景.我的意思是,为什么你需要一个变量作为类类型？有人可以给我一些例子吗？谢谢.

编辑:抱歉,我在原帖中使用了"赋值构造函数"而不是"赋值运算符".现在修复了.

事实证明,在以下代码中调用了复制构造函数而不是赋值运算符.谁能告诉我这背后的原因？谢谢.

class A

{
int i;
public:
A(int ii) { i = ii; }
A(const A& a) { i = a.i; i++; }
A& operator=(const A& a) { i = a.i; i--; }
};
int main(void)
{
A a(4);
A b = a;
return 0;
}