Блог

ОТВЕТ НА ВОПРОС В КОММЕНТАРИЯХ Из-за моей репутации я не могу ответить на него обычным способом. Я добавлю подробности в ответ позже, уже рассмотренный в комментариях. Спасибо.**

Всем привет —

Как вы, без сомнения, увидите на основе вопроса, я новичок в C , но имею опыт работы с некоторыми языками более высокого уровня. (Что, похоже, больше вредит, чем помогает)

Для класса мне нужно создать оболочку для массива, типизированного в целых числах. (На этом этапе класса нет шаблонов) Мне также нужно разрешить классу иметь ненулевой начальный индекс. Я использую массив-член в классе для хранения своих данных (на данный момент в классе еще нет векторов) и выполняю некоторый перевод из общедоступных методов для доступа к соответствующему элементу внутреннего массива.

Проблема, с которой я сталкиваюсь, заключается в том, что я не знаю размер внутреннего массива во время компиляции, поэтому я объявляю его как глобальный указатель класса и настраиваю размер в конструкторе. Фрагмент кода приведен ниже, в проблемной области:

 int *list;
safeArray::safeArray(int start, int initialSize)
{
    if(initialSize <= 0)
    {
        throw "Array size must be a positive integer";
    }
    maxSize = initialSize   1;
    startIndex = start;
    endIndex = start   initialSize;
    list = new int[maxSize];    // Error thrown here
    int *tempArray = new int[maxSize];
    copyArray(tempArray);
    clearArray();   
}
  

Ошибка, которую я получаю, заключается в

Incompatible types in assignment of 'int*' to 'int[0u]'

Я не уверен на 100%, каков тип int [0u]. Это буквальное значение равно нулю, а u означает unsigned? Я проверил в отладчике, что maxSize содержит значение, и я также заменил его постоянным целочисленным значением и получил ту же ошибку.

Поскольку моя int *tempArray = new int[maxSize]; строка работала, я подумал, что это может быть как-то связано с необходимостью одновременного объявления и определения размера, поэтому я решил выполнить memcpy. (Что на самом деле выходит за рамки назначения, поэтому должно быть что-то еще, чего мне не хватает) memcpy завершается с ошибкой, потому что кажется, что я загромождаю другие свои переменные. Когда я печатаю адрес списка в GDB, он выдает мне тот же адрес, что и у другой глобальной переменной в моем коде, так что route также, казалось, выходил за рамки назначения.

Общая тема, которую я видел на других форумах, заключается в том, что вы не можете назначать массивы, как другие переменные, но я не думал, что это будет включать в себя new инструкцию. Я ошибаюсь в этом предположении?

Единственные ошибки компиляции, которые я в настоящее время вижу, — это ошибка, указанная выше, и я вижу ее для каждого list = new int[maxSize]; оператора в коде.

Мои вопросы:

1. Что это за тип int[0u] и где генерируется этот тип? Это должно быть из инструкции new, верно?

2. Каков наилучший способ использования ресурса динамического массива внутри класса? Помимо использования вектора? =)

Я думаю, что это вся соответствующая информация, но приношу извинения, если я пропустил важную часть данных. Ниже приведен остальной код реализации.

 /*
 *  safeArray.cpp
 *  safearray
 *
 *  Created by Jeffery Smith on 6/1/11.
 *  
 *
 */

#include "safeArray.h"
#include amp;<iostreamamp;>


using namespace std;


    int startIndex = 0;
    int endIndex = 0;
    int maxSize = 1;
    int currentSize = 0;
    int *list;

safeArray::safeArray(int start, int initialSize)
{
    if(initialSize <= 0)
    {
        throw "Array size must be a positive integer";
    }
    maxSize = initialSize   1;
    startIndex = start;
    endIndex = start   initialSize;
    list = new int[maxSize];    // Error thrown here
    int *tempArray = new int[initialSize   1];
    copyArray(tempArray);
    clearArray();

}

safeArray::safeArray(const safeArray amp;sArray)
{
    list = new int[sArray.maxSize];
    copyArray(sArray);
    startIndex = sArray.startIndex;
    endIndex = sArray.endIndex;
    maxSize = sArray.maxSize;
    currentSize = sArray.currentSize;
}

void safeArray::operator=(const safeArray amp;right)
{
    list = new int[right.maxSize];
    copyArray(right);
    startIndex = right.startIndex;
    endIndex = right.endIndex;
    maxSize = right.maxSize;
    currentSize = right.currentSize;
}

safeArray::~safeArray()
{
    delete [] list;
}



int safeArray::operator[](int index)
{
    if(OutofBounds(index))
    {
        throw "You tried to access an element that is out of bounds";
    }
    return list[index - startIndex];
}

void safeArray::add(int value)
{
    if(this->isFull())
    {
        throw "Could not add element. The Array is full";
    }
    currentSize  ;
    list[currentSize   startIndex];
}

void safeArray::removeAt(int value)
{
    if(OutofBounds(value))
    {
        throw "The requested element is not valid in this list";
    }
    compressList(value);
    currentSize--;
}

void safeArray::insertAt(int location, int value)
{
    if(OutofBounds(location) || this->isFull())
    {
        throw "The requested value is either out of bounds or the list is full";
    }
    expandList(location, value);
    currentSize  ;
}


void safeArray::clearList()
{
    clearArray();
}

bool safeArray::isFull()
{
    return(maxSize == currentSize);
}

int safeArray::length()
{
    return currentSize;
}

int safeArray::maxLength()
{
    return this->maxSize;
}

bool safeArray::isEmpty()
{
    return(currentSize == 0);
}

bool safeArray::OutofBounds(int value)
{
    return (value > endIndex || value < startIndex);
}

void safeArray::clearArray()
{
    for(int i = 0; i < maxSize; i  )
    {
        list[i] = 0;
    }
    currentSize = 0;
}

void safeArray::compressList(int value)
{
    for(int i = value; i < endIndex; i  )
    {
        list[i] = list[i   1];
    }
}

void safeArray::expandList(int location, int value)
{
    int tempHolder = list[location];
    list[location] = value;
    for(int i = location; i < endIndex; i  )
    {
        tempHolder = list[location];
        list[location] = value;
        value = tempHolder;
    }
}

void safeArray::copyArray(int *srcAddr )
{

    memcpy(list, srcAddr, sizeof(int) * maxSize);

}

void safeArray::copyArray(const safeArray amp;sArray)
{

    memcpy(list, amp;sArray, sizeof(int) * maxSize);

}
  

Вот определение заголовка:

 
/*
 *  safeArray.h
 *  safearray
 *
 *  Created by Jeffery Smith on 6/1/11.
 *  Copyright 2011 Accenture. All rights reserved.
 *
 */



class safeArray {

public:
    safeArray(int,int);    //Standard constructor
    ~safeArray();          //Destructor
    int operator[](int);
    void operator=(const safeArrayamp;);   //Assignment overload
    safeArray(const safeArray amp;sArray); //Copy Constructor

    void add(int);
    int maxLength();
    int length();
    bool isFull();
    bool isEmpty();
    void clearList();
    void removeAt(int);
    void insertAt(int,int);

protected:
    int list[];
    int startIndex;
    int endIndex;
    int maxSize;
    int currentSize;

private:
    void clearArray();
    bool OutofBounds(int);
    void expandList(int,int);
    void compressList(int);
    void copyArray(int*);
    void copyArray(const safeArrayamp;);
};
  

int[0u] ? Я полагаю, что в C можно иметь массивы нулевой длины в конце структур, чтобы эффективно разрешать использование структур переменного размера, но в C это не делается. Я не вижу в вашем коде ничего, что было бы незаконным кодом. Ужасно, да, незаконно, нет. Вам нужно опубликовать содержимое safearray.h , если оно включает стандартные заголовки, то ваше использование using namespace std; может легко стать причиной проблемы.

Кроме того, глобальные переменные являются плохими. Просто поместите указатель внутри класса — вам в принципе никогда не придется использовать глобальные переменные, если вы не делаете что-то очень неправильное. Тем более, что это, скажем, оставляет вас открытым для затенения переменных, конфликтов имен и других серьезных проблем. О, и вам следует создать класс исключений, предпочтительно производный от std::exception или std::runtime_error . Никто не будет пытаться перехватить const char* . Вам не следует использовать std пространство имен — вы напрашиваетесь на проблемы. И вы не вызываете конструктор копирования или оператор присваивания, но используете memcpy для копирования ваших элементов? У вас также произошла утечка памяти в нескольких местах — начиная с оператора присваивания.

 template<typename T> class safe_array {
    char* list;
    std::size_t arrsize;
    void valid_or_throw(std::size_t index) {
        if (index <= arrsize) {
            throw std::runtime_error("Attempted to access outside the bounds of the array.");
    }
public:
    safe_array(std::size_t newsize) 
    : list(NULL) {
        size = arrsize;
        list = new char[arrsize];
        for(std::size_t i = 0; i < arrsize; i  ) {
            new (amp;list[i * sizeof(T)]) T();
        }
    }
    safe_array(const safe_arrayamp; ref) 
    : list(NULL) {
        *this = ref;
    }
    safe_arrayamp; operator=(const safe_arrayamp; ref) {
        clear();
        arrsize = ref.size;
        list = new char[arrsize];
        for(std::size_t i = 0; i < arrsize; i  ) {
            new (amp;list[i * sizeof(T)]) T(ref[i]);
        }        
    }
    Tamp; operator[](std::size_t index) {
        valid_or_throw(index);
        return static_cast<Tamp;>(list[index * sizeof(T)]);
    }
    const Tamp; operator[](std::size_t index) {
        valid_or_throw(index);
        return static_cast<const Tamp;>(list[index * sizeof(T)]);
    }
    void clear() {
        if (list == NULL)
            return;
        for(std::size_t i = 0; i < size; i  ) {
            (*this)[i].~T();
        }
        delete[] list;
        list = NULL;
        arrsize = 0;
    }
    std::size_t size() {
        return arrsize;
    }
    bool empty() {
        return (list == NULL);
    }
    ~safe_array() {
        clear();
    }
};
  

Я подготовил относительно быстрый пример класса, который должен указать вам более общее направление. Он не предлагает всей функциональности vector , например, нет автоматического изменения размера или буферизации емкости (и нескольких других недостатков), и я вполне уверен, что, вероятно, забыл пару вещей, но это начало.

@Bo помог мне в комментариях. Оказывается, у меня было старое объявление int list [] в моем заголовочном файле, которое я никогда не менял. Таким образом, ошибка компилятора, которую он выдавал, была вызвана объявлением там. После этого все пошло прахом.