相关疑难解决方法(0)

我试图确定一个以字符为元素的向量中最常见的字符.

我在想这样做:

• 循环遍历向量并创建一个映射,其中一个键将是向量中找到的唯一字符.相应的值将是该char的频率的整数计数.
• 在浏览完向量中的所有元素后,地图将包含所有字符频率.因此,我将不得不找到哪个键具有最高值,从而确定向量中最常见的字符.

这似乎很复杂,因此我想知道是否有人可以建议这种方法在性能/良好编码方面是否被认为是"可接受的"

这可以用更好的方式完成吗？

我试图为wstring指针赋值,并且没有赋值; 但是,当我打破创建并将指针分配到两行时,它可以工作.为什么是这样？

例如:

std::wstring* myString = &(L"my basic sentence" + some_wstring_var + L"\r\n");

以上不起作用,但下面的确有效:

std::wstring temp = (L"my basic sentence" + some_wstring_var + L"\r\n");
std::wstring* myString = &temp;

我在某处发现了以下代码,我想知道它是否合法在C++中.ret变量是堆栈变量,一旦foo返回分配给ret的内存不再存在.但是string是一个类,我认为复制构造函数被调用来将ret的内容复制到var.这是真的？以下是一段有效的代码吗？

    string foo(int x)
    {
        string ret; 
        //some operation on ret

        return ret; 
    }
    string callingFunc()
   {
        string var = foo(2); 
        // some operation on var
   }

如果我有一个未命名的unique_ptr对象,持有一个对象Foo,为什么该对象在被添加到向量时不会被删除？

例:

vec.push_back(std::unique_ptr<Foo>(new Foo())));

为什么不删除Foo？我试图实现这个,但我似乎无法解决这个问题,因为我删除了析构函数中的对象.

我有巨大的结构 DataFrom 和 Data （实际上有不同的成员）。数据是从 DataFrom 创建的。

struct DataFrom{
    int a = 1;
    int b = 2;
};
static DataFrom dataFrom;   
struct Data{
    int a;
    int b;
};    
class DataHandler{
    public:
        static Data getData(const DataFrom& data2){
            Data data;
            setA(data, data2);
            setB(data, data2);
            return data;
        }
    private:
        static void setA(Data& dest, const DataFrom& source){
            dest.a = source.a;
        }
        static void setB(Data& dest, const DataFrom& source){
            dest.b = source.b;
        }
};
int main(){
    auto data = DataHandler2::getData(dataFrom); // copy of whole Data …

这是我自己的Point类(Point.h):

class Point {
public:
    Point(double x, double y, double z);
    Point(const Point& orig);
    virtual ~Point();
    double getX();
    double getY();
    double getZ();
    void writeOut();
private:
    double x, y, z;
};

在这里,我创建一个点并将其添加到vector<Point>(main.cpp):

Point* p = new Point(0.1,0.2,0.3);
vector<Point>* points = new vector<Point>;
points->push_back(*p);
//doing stuff
delete points;

我的问题是:矢量制作Point的副本并存储它(所以我也需要delete p;),或者它是否存储之前创建的一个实例？

更新:

我在这里读到push_back"在向量的末尾添加一个新元素,在其当前的最后一个元素之后.val的内容被复制(或移动)到新元素." 但是哪一个？复制还是移动？它是如何确定的？

据我所知std::move(相同static_cast<T&&>)将变量转换为rvalue并分配给左值,因此我想在下面的代码中:

int a = 1;
int b = static_cast<int&&>(a);

b并a具有相同的地址,但在VS中,它打印不同的地址.

int a = 1;
int b = static_cast<int&&>(a);
cout << hex << &a << endl;
cout << hex << &b << endl;

如果此后a仍然指向不同的内存位置,std::move在这种情况下使用有什么好处？

在处理动态内存分配的类中，浅复制基本上会导致程序删除资源两次。在移动操作中，原始指针不再指向资源，那么为什么在移动语义中会出现相同的行为呢？例如：

#include <utility>
#include <cstring>
using namespace std;
class MyString
{
    char* cstr;
 public:
    MyString(const char* arg)
    : cstr(new char[strlen(arg)+1])
    {
        strcpy(cstr, arg);
    }
    MyString(MyString&&) = default;
    MyString& operator=(MyString&&) = default;
    MyString(const MyString&) = delete;
    MyString& operator=(const MyString&) = delete;
    ~MyString()
    {
        delete[] cstr;
    }
};

int main()
{
    MyString S1{"aaa"};
    MyString S2 = move(S1); // error

}

我尝试过 3 个不同的编译器，得到了相同的结果。

有很多文章讨论价值语义与参考语义,也许更多的文章试图解释移动语义.但是,没有人谈论过值语义和移动语义之间的联系.它们是正交概念吗？

注意:这个问题不是关于比较值语义和移动语义,因为很明显这两个概念不是"可比的".这个问题是关于他们是如何联系的,特别是(如@StoryTeller所说),讨论(如何):

移动语义有助于更多地使用值类型.

I have a constructor that looks like this:

Thing::Thing(std::vector<uint8> & data){
    m_data = data; // m_data is also a vector<uint8>
    // do other stuff
}

However, data holds a pretty large chunk of memory, and instead of copying it, I'd like data to simply give it up to m_data, as the caller will never need it after constructing this object. What's the best way to do this in C++?