小编Che*_*ebz的帖子

如何将指针对齐到16字节边界？

我找到了这段代码,不确定它是否正确

char* p= malloc(1024);

if ((((unsigned long) p) % 16) != 0) 
{
     unsigned char *chpoint = (unsigned char *)p;        
     chpoint += 16 - (((unsigned long) p) % 16);
     p = (char *)chpoint;
}

这会有用吗？

谢谢

我正在尝试应用补丁但我得到一个空白的错误消息(它没有任何文本或任何东西).我有TortoiseSVN的最新版本.

我正在尝试优化我的代码,并在其上运行VS性能监视器.

它表明浮点数的简单分配占据了很大一部分计算能力？我不明白这是怎么可能的.

这是TagData的代码:

public class TagData
{
    public int tf;
    public float tf_idf;
}

所以我真正做的就是:

float tag_tfidf = td.tf_idf;

我很迷惑.

我对在堆上分配对象和在堆栈上分配的主题以及何时以及如何调用delete()有点困惑.

例如,我有类Vector.我想做一些这些.

我可以做到这一点

Vector** v = new Vector*[100]; //create an array of 100 pointers to 100 Vector objects

据我所知,这将在堆上分配所有东西(除了指针地址)？所以为了释放记忆,我需要:

for (int i = 0; i < 100; ++i)
{
   delete(v[i]);
}
delete(v);

要不就

delete(v);

足够？

另一个例子:

Vector* v = Vector[100];

在这种情况下发生了什么？分配在哪里发生？堆还是堆？我还需要打电话吗？

delete(v);

但这不是全部问题,对不起长篇大论...

例:

class Vector
{
  int x, y, z;
}

Vector* v = new Vector();

是否分配了x,y,z？堆还是堆？

或者这个怎​​么样:

class Vector2
{
   int items[10];
}

Vector2* v2 = new Vector2();

项目[10]在哪里分配？如何删除v2？我需要自定义析构函数吗？

最后但并非最不重要的是这个怎么样:

class Vector3
{
   int* items;
}

Vector3 v3 …

我有一个填充回调函数的向量,我想在添加它之前检查函数的回调是否已经存在.我不知道它到目前为止是否会工作甚至不能编译.

vector<std::function<void(void*)>> _callbacks;

void Event::RegisterCallback(std::function<void(void*)> callback)
{
    if (callback == NULL)
        return;

    vector<std::function<void(void*)>>::iterator it = std::find(_callbacks.begin(), _callbacks.end(), callback);

    if (it == _callbacks.end())
    {
        _callbacks.push_back(callback);
    }
    else
    {
        //print error
        throw;
    }
}

这给出了一个编译错误:"算法中的重载分辨率选择删除操作符'=='"(805).这与find函数调用有关.

如何让它工作,甚至将函数调用与正确的方法进行比较？

谢谢

我正在尝试将一个分支与多个已移动的文件集成。它们没有在目标分支中修改，但显示为冲突。单击“接受源”时，文件会从冲突对话框中静默消失，但仍然在更改列表中标记为冲突。我可以解决此问题的一种方法是添加 -Di 标志，但这对我的团队来说是一个很大的禁忌。我还尝试通过命令行进行 p4 解析，结果相同（没有错误或任何问题，但没有解决任何问题）。

发生了什么事以及如何解决保留移动历史记录？

我在接受采访时被问到这个问题.我完全无能为力地解决这个问题......

/* You are writing a unit test to confirm the correctness of a function which
takes 3 float values as arguments. You decide to stress test it by testing
1000000 'random' inputs.
You find that the function will fail, but very rarely, so you include code
to print out all failure cases, hoping to grab a simple repro case which you
can debug into.
Note: All code here is run in a single-threaded environment. */

//...
// Some code …

对象foo被写入平台1上的新文件,如下所示:

write( file, &myFoo, sizeof(struct foo) );

...然后使用以下方式在平台2上阅读:

read(file, &myFoo, filesize(file) );

该foo对象具有以下定义:

struct foo
{
    char  a;
    int   b; 
    long  c;
    char* d;
};

foo在平台2上加载时可能会出现什么问题？

我在使用 C# 时遇到问题，给出“使用未分配的局部变量”编译错误。我缺少什么？

// returns generic result of a function with error message 
// why the function failed
public class Result
{
    public bool isSuccess = true;
    public string errorMessage = string.Empty;

    public static implicit operator bool(Result r)
    {
        return r.isSuccess;
    }

    public static Result operator &(Result a, Result b)
    {
        return !a.isSuccess ? a : b;
    }

    public static Result operator |(Result a, Result b)
    {
        if (a.isSuccess)
        {
            return a;
        }
        if (b.isSuccess)
        {
            return b;
        }
        return …

这就是我想要做的

class A
{
    virtual void foo();
}

class B : A
{
    virtual override void foo();
}

class C : B
{
    override void foo();
}

所以我想在调用C.foo()时看到的是A.foo(),B.foo(),C.foo()

但我不认为虚拟覆盖可以在同一个函数定义中使用.我该怎么回事呢？

谢谢 - 迈克

我有一个简单的结构,朋友会被分配new,所以显然我需要delete这样.但是,通过姓名和电子邮件,我不太确定.

struct Member
{
    char * name;
    char * email;
    LinkedList<Member> * friends;

    Member() : name(nullptr), email(nullptr), friends(nullptr)
    {
    }

    ~Member()
    {
        if (friends)
            delete friends;
    }
};

如果,例如,我有什么

Member m;
m.name = "John Doe";
m.email = "johnDoe0@email.com";

我还需要delete姓名/电子邮件吗？

继承我的班级

class Vector
{
public:
    Vector();
    Vector(float x, float y, float z);

    float x;
    float y;
    float z;

    Vector &operator+(const Vector &other) const;
    Vector &operator+=(const Vector &other);
    Vector &operator*(float n) const;
};

//op overloading functions impl
Vector &Vector::operator+(const Vector &other) const
{
    Vector result = *this;
    result.x += other.x;
    result.y += other.y;
    result.z += other.z;
    return result;
}

Vector &Vector::operator+=(const Vector &other) 
{
    this->x += other.x;
    this->y += other.y;
    this->z += other.z;
    return *this;
}

Vector &Vector::operator*(float n) const
{ …