标签: pointers

我需要一个shared_ptr类似的对象,但在我尝试访问其成员时会自动创建一个真实的对象.

例如,我有:

class Box
{
public:
    unsigned int width;
    unsigned int height;
    Box(): width(50), height(100){}
};

std::vector< lazy<Box> > boxes;
boxes.resize(100);

// at this point boxes contain no any real Box object.
// But when I try to access box number 50, for example,
// it will be created.

std::cout << boxes[49].width;

// now vector contains one real box and 99 lazy boxes.

是否有一些实现,或者我应该自己编写？

我有一个char指针,用于存储字符串.它稍后在程序中使用.

我已经声明并初始化为:

char * p = NULL;

我只是想知道这是不是很好的做法.我正在使用gcc 4.3.3.

我有一个函数,它对一段数据进行操作(比方说,一个int),我想通过传递对valule的引用来改变它.因此,我有这个功能:void myFunction(int *thing) { ... }.当我使用它时,我称之为:myFunction(&anInt).

由于我的功能经常被调用(但是来自许多不同的地方),我担心它的性能.我将其重构为函数的原因是可测试性和代码重用.

编译器是否能够优化函数,将其内联直接操作我的anInt变量？

我希望你能在这个问题的精神中接受这个问题(即我不会过早地担心优化,我对答案感到好奇).同样,我不想把它变成一个宏.

由于遗留原因,我需要使用侵入式指针,因为我需要能够将原始指针转换为智能指针.

但是我注意到没有弱的侵入式指针可以提升.我确实在boost线程列表上找到了关于它的讨论,但没有具体的.

有谁知道弱侵入指针的线程安全实现？

谢谢Rich

共享指针(例如boost :: shared_ptr或新的std :: shared_ptr)和垃圾收集方法(例如用Java或C#实现的那些)之间有什么区别？我理解它的方式,共享指针跟踪变量指向资源的次数,并在计数达到零时自动销毁资源.但是,我的理解是垃圾收集器还管理内存资源,但需要额外的资源来确定对象是否仍然被引用,并且不一定会立即破坏资源.

我的假设是否正确,使用垃圾收集器和共享指针之间是否存在其他差异？此外,如果有人执行类似的任务但性能数据不同,为什么有人会在共享指针上使用垃圾收集器呢？

如果我定义一个map像这样的指针:

map<int, string>* mappings;

mappings是一个指针.我应该如何使用此指针来操作地图？

我有一个带有静态成员的类,它是一个像这样的指针:

animation.h

class Animation
{
public:
    Animation();
    static QString *m;

};

animation.cpp

#include "animation.h"

QString* Animation::m = 0;

Animation::Animation()
{
}

当我尝试从另一个类初始化那个'm'指针时:

Animation::m = new QString("testing");

有用.

但是当我这样做的时候:

QString x("Testing");
Animation::m = &x;

程序崩溃了.

第二种方法有什么问题？

此外,我希望将该静态指针设置为私有,以便我可以为其创建静态getter和setter函数.setter应该使用第二种方法,因为'x'将出现在参数中,所以我被卡住了.

谢谢你的帮助!

考虑以下程序:

#include <string>

struct S {
    S (){}

private:
    void *ptr = nullptr;
    std::string str = "";
};

int main(){}

在使用-Weffc++GCC 4.7.1 编译时,这将吐出:

warning: 'struct S' has pointer data members [-Weffc++]
warning:   but does not override 'S(const S&)' [-Weffc++]
warning:   or 'operator=(const S&)' [-Weffc++]

这通常没问题,除了这个例子的几个东西:

1. 如果我注释掉任何构造函数,指针声明或字符串声明,警告就会消失.这很奇怪,因为你认为指针就足够了,但事实并非如此.此外,将字符串声明更改为整数声明也会导致它消失,因此只有在有字符串(或可能是其他选择类)时才会出现.为什么在这种情况下警告会消失？

2. 通常,当所有指针都在指向现有变量(通常由OS维护)时,会出现此警告.没有new,没有delete.当复制带有句柄的类时,我不想要深层复制.我希望两个句柄指向同一个内部对象(例如窗口).有没有办法让编译器实现这一点,而不会不必要地重载复制构造函数和赋值运算符,或完全禁用警告#pragma？当三法则甚至不适用时,为什么我首先被困扰？

为了避免继续使用->而是直接使用对象,可以接受的做法是:

obj x = *(new obj(...));
...
delete &obj;

我被问到这个面试问题,我弄错了."输出是什么":我的答案是135,实际输出是136.这意味着指向两个父类的指针不相等,即使它们通过了等于子类的先前测试.我以为我理解了c ++指针,但这让我难以理解.虽然我想我知道发生了什么,但我不确定为什么.那里有哪些c ++专家可以提供技术解释？看来前两个比较本质上更合乎逻辑,而最后一个比较更具文字性......

#include <iostream>

class A
{
    public:
    A() : m_i(0) { }

    protected:
    int m_i;
};

class B
{
    public:
    B() : m_d(0.0) { }

    protected:
    double m_d;
};

class C
    : public A, public B
{
    public:
    C() : m_c('a') { }

    private:
    char m_c;
};

int main()
{
    C c;
    A *pa = &c;
    B *pb = &c;

    const int x = (pa == &c) ? 1 : 2;
    const int y = (pb == &c) …