标签: pointers

这个问题可能很愚蠢,但我想知道,如果函数返回指向对象的指针时调用了复制构造函数？另外,请考虑以下事项

A* a1 = new A(); 
A* a = a1.GetPointer();

A* GetPoineter()
{

.....
return new A();
}

那也是

A* a = a1.GetPointer(); 

调用复制构造函数？

如果我删除a,它还会删除指向的地址a1吗？

似乎无法解决为什么我在打印内容时从此链接列表结构获取垃圾输出.

我的目标是在列表中添加任何内容,一些字符串,char by char,它应该反向打印出来.我使用额外的头部+尾部结构的原因是我可以打印出反向输入的订单行.

typedef struct List {
 char c;
 struct List *next;
}List;

typedef struct  {
 List *head;
 List *tail;
}FullList;

List* InsertList(int hd, List* t1) {
 List *t = (List*)calloc(1,sizeof(List));
 t->c = hd; 
 t->next = t1;
return t;
}


FullList addToStart(FullList c, char element) {
 if (c.head == NULL) {
    c.head = c.tail = InsertList(element, NULL);
 }else {
    c.head = InsertList(element, c.head);
 }
return c;
}

int main(void) {
 FullList InOrder;
 FullList Reverse;
 InOrder.head = NULL;
 Reverse.head = …

我正在使用上面的代码动态分配一个数组,在函数内部做一些工作,返回一个数组元素并释放函数外部的内存.但是当我尝试释放数组时,它不会释放内存,而且我有内存泄漏.指向myArray变量的调试器向我显示错误CXX0030.为什么？

struct MYSTRUCT
{
    char *myvariable1;
    int myvariable2;
    char *myvariable2;

    ....
};

void MyClass::MyFunction1()
{
    MYSTRUCT *myArray= NULL;

    MYSTRUCT *myElement = this->MyFunction2(myArray);

    ...

    delete [] myArray;
}

MYSTRUCT* MyClass::MyFunction2(MYSTRUCT *array)
{
    array = (MYSTRUCT*)operator new(bytesLength);

    ...

    return array[X];
}

int buf1[] = {0,0,0,0,0};

int* buf2 = new int[5]; //assume every element is initialzed to 0 as well

我能想到的唯一区别是buf1是对数组的引用,而buf2是指向数组的指针.换句话说,buf1总是引用数组,而buf2也指向其他地方.

除了上面提到的那个,声明(和初始化数组)的两种方式之间还有什么区别吗？

我想在我的程序中创建一个树结构.现在我有类似于以下内容:

class tree_node
{
    public:
        tree_node (tree_node* parent) : parent_(parent)
        {
            parent_.add_child(this);
        }

    private:
        std::vector<tree_node*> children_;
        tree_node* parent_;
}

我对这个设计的主要关注是tree_node该类可以删除它的任何子节点和父节点.我想改变设计以禁止这种情况.所以:

• 我可以以某种方式更改设计以使用引用而不是指针吗？(引用的向量不起作用).
• 如果我使用引用,我如何处理根节点(没有父节点)的特殊情况？
• 我可以禁止在tree_node课堂上删除孩子/父母吗？

欢迎任何其他实现我的目标的想法.

我有两个类,一个扩展另一个.他们都有一个叫做doSomething()执行不同的方法.我希望能够有一个我可以切换class A到的指针,class B并让其余的代码运行相同,因为它们每个都有相同的方法名称.这是可能的,这是正确的方法吗？另外,我对C++很陌生,所以它可能只是一个问题.

class A {
    void doSomething()
    {
        // does something
    }
};

class B: public A {
    void doSomething()
    {
        //does something else
    }
};


main()
{
    A *ptr = new A;
    B *bptr = new B;

    // a giant loop

    ptr->doSomething();


    if(condition) 
    {
        ptr = bptr;
    }
}

我写了一个简单的程序来逐个对数字进行重复排序,然后将它们逐个插入到树中.我的问题是,我无法插入root的子节点,因为我无法将下面的函数更改为call-by-reference类型.

以下q参数需要保持root的地址值.

void insertNode(int data, node *q, node *parent){
    if(q == NULL){
        node *p = createNode(data);
        p -> parent = parent;
        p -> key = generateKey(p);
        int i;
        for(i = 0;table[i][1] != 0;i++);
        table[i][1] = p -> data;
        table[i][0] = p -> key;
        q = p;
    }
    else if(q -> left > q -> right || q -> left == q -> right){
        q -> right++;
        insertNode(data, q -> rightChild, q);
    }
    else if(q -> right > q -> left){ …

如果我有一个class Foo和原型的方法void bar(Foo* foo).可以这样做bar(&Foo());吗？

我知道它编译和工作,但由于我对C++比较陌生,我想知道创建的实例在使用后是否会被正确销毁,或者在做这个时我是否还要担心其他任何事情.

我正在尝试用C++实现有向图.然而,我无法用我的RemoveEdge功能,之后我打电话的功能和它使用上的指针delete运算符,并设置指针nullptr,它不归零功能范围之外.

我不确定我是否已经清楚地说明了我的问题,但也许一些代码会有所帮助.

Graph.h

template<class TVertex, class TEdge, class TWeight>
class Graph
{
protected:
    std::list<Vertex<TVertex, TEdge, TWeight>*>* _Vertices;
    std::list<Edge<TVertex, TEdge, TWeight>*>* _Edges;
public:
    Graph();
    int TotalVertices();
    int TotalEdges();
    std::list<Vertex<TVertex, TEdge, TWeight>*>* Vertices();
    std::list<Edge<TVertex, TEdge, TWeight>*>* Edges();

    Vertex<TVertex, TEdge, TWeight>* FindVertex(const TVertex&);
    Vertex<TVertex, TEdge, TWeight>* InsertVertex(const TVertex&);
    void RemoveVertex(const TVertex&);

    Edge<TVertex, TEdge, TWeight>* FindEdge(const TEdge&);
    Edge<TVertex, TEdge, TWeight>* InsertEdge(const TVertex&, const TVertex&, const TEdge&, const TWeight&);
    void RemoveEdge(const TEdge&);
};

Graph.FindEdge()

template<class TVertex, class TEdge, class TWeight>
Edge<TVertex, TEdge, TWeight>* …

考虑一下:

#include <iostream>
using namespace std;
class A{
   protected:
       void some_function(int params)
       {
        //inside A: do something A related 
       }
};

class B: public A{
public:
    void call_some_function(int params)
    {
    some_function(params); // Simple call to A::some_function and NOTHING MORE.
    }
};


int main(int argc, char *argv[])
{
   A* a = new A();

   ((B*)(a))->call_some_function(20); // Is it OK ?
}

此代码有效使用它有什么危险？