标签: pointers

我正在学习C++,这次我搞乱了指针,研究了this指针和多态.我的问题是,转换是否安全,我知道基本上我可以m_uConnectedUsers直接从CUser课堂上访问因为'公共',但我可能会找到一个需要它的机会,我想知道你的专业人士的意见它.

#include <windows.h>
#include <iostream>

using namespace std;


class CUserCounter
{
public:
    CUserCounter();
    virtual ~CUserCounter(){};

    BOOL m_bEmpty;
    u_long m_uConnectedUsers;
};

CUserCounter::CUserCounter()
{
    m_bEmpty = TRUE;
    m_uConnectedUsers = 0;
}

class CUser : public CUserCounter
{
public:
    CUser(LPCTSTR szName, BOOL bConnected, BOOL bChatting = FALSE );
    virtual ~CUser(){};

    BOOL m_bConnected;
    BOOL m_bIsChatting;
    TCHAR szCharName[32];

    bool IncreaseMoverMeter( unsigned uMeters );
};

CUser::CUser( LPCTSTR szName, BOOL bConnected, BOOL bChatting )
{
    if( szName )
    {
        if( strlen( …

众所周知,有很多方法可以访问班级成员,我现在的问题是.如果类构造函数/解构函数是公共的,那么'new'用法是允许的,也是'extern',如果它是私有的,我可以使'GetInstance'只允许不允许'new'使用的类,这对类很有用应该只有1个指向实例(例如,计算当前登录用户的服务器),而"new"适用于指向许多对象的classe(例如指向新对象的类,例如a新玩家记录int,它会创建一个指向它们每个on的新指针),而map会存储指向该对象的'new'的指针.问题是,不应该允许'extern'从全局对象私有构造函数访问吗？既然'新'用法是不允许的？看看下面的例子:

#include <windows.h>
#include <cstdlib>
#include <iostream>
#include <map>

using namespace std;


//CMover.h-------------------------------------
#define MAX_MOVER_NAME 32

class CMover
{
private:
    BOOL m_bInitialized;
    BOOL m_bIsWalking;
    unsigned m_uMetersPercused;
    TCHAR m_szName[MAX_MOVER_NAME+1];

    //CMover( LPCTSTR szMoverName, BOOL bInitialized = TRUE, BOOL bWalking = TRUE, unsigned uMeters = 0 );

public:
        CMover() { };
    virtual ~CMover(){};
};
//---------------------------------------------



//CMover.cpp---------------
CMover g_Mover; //CMover was created in order to have many 'new' usage, so each 'new' object points to a new player
// Making a global object of …

我正在寻找一种方法A在容器对象内插入多个类型的对象,而不是A在插入过程中复制每个对象.一种方法是A通过引用传递对象,但不幸的是,据我所知,STL容器只接受按插值的值传递对象(出于很多好的理由).通常情况下,这不是问题,但在我的情况下,我不希望调用复制构造函数并将原始对象销毁,因为它A是C库的包装器,其中包含一些C语言指针到内部结构,将与原始对象一起删除...

给定一个特定的索引,我只需要一个可以返回其中一个对象的容器,并存储一定数量的在运行时确定的项目,所以我想也许我可以编写自己的容器类,但我不知道如何这样做得恰到好处.

另一种方法是将指针存储A在容器内部,但由于我对这个主题没有太多的知识,在STL容器中插入指向对象的指针是什么？例如:

std::vector<A *> myVector;
for (unsigned int i = 0; i < n; ++i)
{
    A *myObj = new myObj();
    myVector.pushBack(myObj);
}

可能有用,但我不确定如何正确处理它以及如何以干净的方式处理它.我应该完全依赖包含myVector的类的析构函数来处理它吗？如果此析构函数在删除其中一个包含的对象时抛出异常会发生什么？

此外,有些人建议使用像shared_ptr或auto_ptr或类似的东西unique_ptr,但我对这么多的选择感到困惑.哪一个是我的方案的最佳选择？

#include<stdio.h>
int main()
{
    char *s[] = { "knowledge","is","power"};
    char **p;
    p = s;
    printf("%s ", ++*p);
    printf("%s ", *p++);
    printf("%s ", ++*p);

    return 0;
}

输出:

现在知道了

请解释从第二个printf()语句特别输出的输出.我认为因为++并且*具有相同的优先级因此*p++ p应首先递增然后使用*(从右到左的关联性为一元运算符).

请看下面的代码:

char* test ( )
{
    char word[20];
    printf ("Type a word: ");
    scanf ("%s", word);
    return word;
}

void main()
{
    printf("%s",test());
}

当函数返回时,变量word被销毁并打印一些垃圾值.但当我更换

char word[20];

通过 char *word;

它打印正确的值.根据我的说法,指针变量应该被破坏,类似于字符数组,输出应该是一些垃圾值.任何人都可以解释一下这种含糊之处吗？

可能重复:
替换itoa()将整数转换为字符串C++？
如何在C++中将数字转换为字符串,反之亦然
将int附加到std :: string

我想将整数转换为字符串,任何一个帮助我进行这些转换？

itoa(*data->userid,buff1,10);
itoa(*data->userphone,buff2,10);

我可以在C++中使用明确指定其内存地址的对象吗？这是因为我为每个实体(对象)分别设置了id.因此,如果我能做到这一点,我将能够通过仅添加指针来遍历所有对象.考虑一下:我有一个内存位置为x的对象.我想用内存位置x +(下一个对象的唯一id)创建下一个对象*K其中K是两个对象之间的恒定间隙(比方说)

我正在使用OpenGL和DirectX,我已经开始为面向对象的游戏类开发基础知识.当前类的结构如下:

对象
--- | ---演员
--------- | ---典当
--------- | ---控制器

所以我有继承继承的类Pawn和Controller类.ActorObject

问题是我需要Controller在pawn类和Pawn控制器类中的实例中引用.
因此我向前宣布Pawn并Controller在Actor.h:

// Actor.h

// (...) Actor Declaration (...)

class Pawn;
class Controller;

然后在Pawn.h:

// Pawn.h

class Pawn : public Actor
{
private:
    Controller* controller;
public:
    void DoSomethingWithController(void);
}

这一切都很好,没有错误.问题是当我想访问该类中的成员时:

void Pawn::DoSomethingWithController(void)
{
    // this->controller-> can't access members like this (members not found)
}

那么,我该怎么做才能在Pawn中有一个Controller指针和一个指向我的Controller中的Pawn的指针,将它们保存在不同的文件(.h和.cpp)中,同时能够访问它的成员？

感谢您的时间.:d

[如果需要更多信息,我会提供]

char *val1 = "/root";
char *val2 = "/p";
val1 = val1+val2;

我想添加2个char指针值并将其分配给第一个值.上面是代码snippt.

我有一个包含几个向量的类,我不确定哪种方法是最好的,但是当我调用析构函数时,它们应该从内存中删除.

标头:

class Test
{
public:
    Test();
    ~Test();

    void AddString(char* text);
    void AddString(string text);

private:
    char * StringToCharPointer(string value);

    vector<char*> *pVector;
}

CPP文件:

Test::Test()
{
};

Test::~Test()
{
    vector<char*>::iterator i;

    for ( i = pVector->begin() ; i < pVector->end(); i++ )
    {
        delete * i;
    }

    delete pVector;
};

char * Test::StringToCharPointer(string value)
{
    char *pChar = new char[value.length()];
    strcpy(pChar, value.c_str());

    return pChar;
};

Test::AddString(char* text)
{
    pVector->push_back(text);
};

Test::AddString(string text)
{
    pVector->push_back(StringToCharPointer(text));
};

所以这里几乎是我使用的所有方法,但有什么不对？