C++ 添加到缓冲区末尾的随机字节

我正在从那个类中重新创建一些System.IO函数。 当我设置一个缓冲区并分配n个字节时，它将读取该缓冲区中的字节，然后将随机字节添加到该缓冲区的末尾

例如：

我的主要意见是：

int main(int argc, char *args[])
{
    SetConsoleTitle(TEXT("Stream Test."));
    cout<<"Press any Key to begin reading.";
    cin.get();
    const char* data = File::ReadAllBytes(args[1]);
    Stream* stream = new Stream(data);
    char* magic = new char[8];
    stream->Read(magic, 0, 8);
    magic[8] = '\0';
    cout<<magic<<endl<<endl;
    delete[]data;
    cout<<"Press any key to quit.";
    cin.get();
    return 0;
}

intmain（intargc，char*args[]）
{
SetConsoleTitle（文本（“流测试”）；
cout您只能使用
运算符我猜文件没有正确打开，因此根本没有设置魔法缓冲区，这会使其保留初始化的垃圾数据：

如果构造函数未能成功打开文件，则对象
尽管没有与流缓冲区关联的文件，但仍会创建
并设置流的failbit（可使用继承的
成员（失败）。

尝试在此过程中添加更多错误检查（使用cout），尤其是在打开和读取缓冲区时。可能会将magic缓冲区设置为零，或者设置为成功时会被覆盖的可识别值。
缺少空终止符？
magic[7]='\0'；
@JesseGood我会试试的。@JesseGood哇，我在做='/0'！！非常感谢，但是你能解释一下为什么我必须首先这么做吗？我在某个地方读到windows并不总是分配你告诉它的n个空间量或这些行的周围的东西。它仍然会有文件中的前8个字节，然后会被丢弃空终止权？@ USE1425433：在C++中，空终止符表示字符串的结尾。没有它，就无法知道字符串何时结束。在C++中，跟踪数组的大小等必须由程序员完成，当您执行<代码> cOut@ DaviSwitts时，它是一个很普通的理解，我只会输出C字符串。控制台..但它不知道从：char*data=new char[8]“你不是说它是一个字符数组8字节长吗？我也应该使用无符号字符吗？”这句话很重要。@ USE1425433号，请自己帮个忙，读一本关于C++的书，而不是假设你可以重用C语言知识，因为它也从C开始。C +数组与C++数组有共同点的唯一的地方是B。球拍。@user1425433:您要传递给
操作员的全部内容
namespace System
{
    namespace IO
    {
        class File
        {
        public:
            static char* ReadAllBytes(const char *name)
            {
                ifstream fl(name, ifstream::in|ifstream::binary);
                fl.seekg( 0, ifstream::end );
                size_t len = fl.tellg();
                char* ret = new char[len+1];
                ret[len] = '\0';
                fl.seekg(0); 
                fl.read(ret, len);
                fl.close();
                return ret;
            }

            //not sure of this use yet.
            static size_t fileSize(const char* filename)
            {
                ifstream in(filename, ifstream::in | ifstream::binary);
                in.seekg(0, ifstream::end);
                return in.tellg(); 
            }
        };

        class Stream
        {
        public:
            const char *_buffer;
            __int64 _origin;
            __int64 _position;
            __int64 _length;
            __int64 _capacity;

            bool _expandable;
            bool _writable;
            bool _exposable;
            bool _isOpen;

            static const int MemStreamMaxLength = 2147483647;

            Stream()
            {
                InitializeInstanceFields();
            }

            Stream(const char *buffer)
            {
                _buffer = buffer;
                _length = strlen(_buffer);
                _capacity = _length;
                _position = 0;
                _origin = 0;
                _expandable = false;
                _writable = true;
                _exposable = true;
                _isOpen = true;
            }

            int ReadByte()
            {
                if (_position >= _length)
                    return -1;
                return _buffer[_position++];
            }

            void Read(char* &buffer, int offset, int length)
            {
                if((_position + offset + length) <= _length)
                {
                    memcpy( buffer, _buffer + (_position + offset), length );
                    _position += length;
                }
            }

            private:
                void InitializeInstanceFields()
                {
                    _origin = 0;
                    _position = 0;
                    _length = 0;
                    _capacity = 0;
                    _expandable = false;
                    _writable = false;
                    _exposable = false;
                    _isOpen = false;
                }
        };
    }
}