如何在不使用常量数组大小的情况下初始化私有类中的数组?

梅娜青塔

我有一个标题和 .cpp 文件。我在初始化数组时遇到困难。问题是我无法指定数组大小。大小取决于用户输入的元素数量。当我创建一个新的dynamicArray时,我相信我必须使用“new”之类的dynamicArray = new string[sizeof(array)](因为我以后必须根据分配删除内存)但是当我通过Linux运行它时,它说它不能出现在常量 - 表达式中。

我对 C++ 还是有点陌生​​。任何反馈表示赞赏。

错误的样子:

图像

我也遇到了标题重新定义的问题,我认为 #pragma 曾经有帮助。我知道 #include "stdafx.h" 对 linux 不利。我每次在 linux 上运行它时都会删除它。

动态字符串数组.cpp

// DynamicStringArray.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "DynamicStringArray.h"
#include "Assignment9Test_V1.cpp"

// copy constructor that copies the array
DynamicStringArray::DynamicStringArray(string array[]) {
    // string *dynamicArray = new string[sizeof(array)]; // without pointer, error with conversion between types
    dynamicArray = new string[sizeof(array)];

    for (int i = 0; i < sizeof(array); i++) {
        dynamicArray[i] = array[i];
    }
}

// default constructor
DynamicStringArray::DynamicStringArray() {
    size = 0;

    dynamicArray = NULL;
    // dynamicArray = new string[size];
}

// frees up dynamic array memory
void DynamicStringArray::destructor(string array[]) {
    delete[] array;
    array = NULL;
}

// return number of entries in array
int DynamicStringArray::getSize() {
    return size;
}

// creates a new dynamic array one element larger than dynamicArray
// copies all elements of dynamicArray to new array and
// add new string to end of new array
// increment size
// delete old dynamicArray
// set new array as dynamicArray
void DynamicStringArray::addEntry(string newString) {
    string *newArray;
    newArray = new string[size + 1];

    for (int i = 0; i < size; i++) {
        newArray[i] == dynamicArray[i];
    }

    int endIndex = sizeof(newArray);
    newArray[endIndex] = newString;

    destructor(dynamicArray);
    dynamicArray = newArray;
}

// searches for dynamicArray for specific string,
// if string not found, return false
// if string is found, create new one size smaller dynamic array
// than dynamicArray
// copy elements of old dynamicArray to new array without the string
// delete old dynamicArray
// decrement size
// return true
bool DynamicStringArray::deleteEntry(string deleteMe) {
    string *newArray;
    newArray = new string[size - 1];

    bool isFound = false;

    for (int i = 0; i < size; i++) {
        if (dynamicArray[i] == deleteMe) {
            i++;
            isFound = true;
        }
        else if (dynamicArray[i] != deleteMe) {
            newArray[i] == dynamicArray[i];
        }
    }

    if (isFound) {
        return true;
        destructor(dynamicArray);

        dynamicArray = newArray;
    }
    else if (!isFound) {
        return false;
    }
}

// returns the string at that index
string DynamicStringArray::getEntry(int findMe) {
    return dynamicArray[findMe];
}

动态字符串数组.h

#pragma once
#include <string>
#include <iostream>

using namespace std;

class DynamicStringArray {
public:
    DynamicStringArray();

    DynamicStringArray(string array[]);

    // overloading the assignment operator

    void destructor(string array[]);
    int getSize();
    void addEntry(string);
    bool deleteEntry(string);
    string getEntry(int);

private:
    int size; // holds number of entries in the array
    string *dynamicArray; // references a dynamic array of type string
};
雷米勒博

您使用new(特别是new[]delete[])来解决这个问题的直觉是正确的。您必须在运行时动态分配数组,因为您在编译时不知道元素的数量。但是,您没有正确使用new[]/ delete[],这就是为什么会出现错误(以及您的代码的许多其他问题)。

尝试更像这样的事情:

动态字符串数组.h

#pragma once
#include <string>

class DynamicStringArray {
public:
    DynamicStringArray();
    DynamicStringArray(const std::string *array, int arraySize);
    DynamicStringArray(const DynamicStringArray &array);
    ~DynamicStringArray();

    DynamicStringArray& operator=(const DynamicStringArray &array);

    int getSize() const;
    void addEntry(const std::string &newString);
    bool deleteEntry(const std::string &deleteMe);
    std::string getEntry(int findMe) const;

private:
    int size; // holds number of entries in the array
    string *dynamicArray; // references a dynamic array of type string
};

动态字符串数组.cpp

// DynamicStringArray.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "DynamicStringArray.h"

// default constructor
DynamicStringArray::DynamicStringArray() {
    size = 0;
    dynamicArray = NULL;
}

// constructor that copies an array
DynamicStringArray::DynamicStringArray(const std::string *array, int arraySize) {
    size = arraySize;
    dynamicArray = new std::string[size];

    for (int i = 0; i < size; i++) {
        dynamicArray[i] = array[i];
    }
}

// copy constructor that copies the array
DynamicStringArray::DynamicStringArray(const DynamicStringArray &array) {
    size = array.size;
    dynamicArray = new std::string[size];

    for (int i = 0; i < size; i++) {
        dynamicArray[i] = array.dynamicArray[i];
    }
}

// frees up dynamic array memory
DynamicStringArray::~DynamicStringArray() {
    delete[] array;
}

// copy assignment operator that copies the array
DynamicStringArray& DynamicStringArray::operator=(const DynamicStringArray &array) {
    if (&array != this) {
        DynamicStringArray copied(array);
        std::string *temp = copied.dynamicArray;
        copied.dynamicArray = dynamicArray;
        dynamicArray = temp;
        size = array.size;
    }
    return *this;
}

// return number of entries in array
int DynamicStringArray::getSize() const {
    return size;
}

// creates a new dynamic array one element larger than dynamicArray
// copies all elements of dynamicArray to new array and
// add new string to end of new array
// increment size
// delete old dynamicArray
// set new array as dynamicArray
void DynamicStringArray::addEntry(const std::string &newString) {
    std::string *newArray = new std::string[size + 1];
    for (int i = 0; i < size; i++) {
        newArray[i] = dynamicArray[i];
    }
    newArray[size] = newString;
    delete[] dynamicArray;
    dynamicArray = newArray;
    ++size;
}

// searches the dynamic array for a specific string,
// if string not found, return false
// if string is found, create new array one size smaller than dynamicArray
// copy elements of old dynamicArray to new array without the string
// delete old dynamicArray and replace with new array
// decrement size
// return true
bool DynamicStringArray::deleteEntry(const string &deleteMe) {
    for (int i = 0; i < size; i++) {
        if (dynamicArray[i] == deleteMe) {
            std::string *newArray = new std::string[size - 1];
            for (int j = 0; j < i; ++j) {
                newArray[j] = dynamicArray[j];
            }
            for (int j = i+1; j < size; ++j) {
                newArray[j-1] = dynamicArray[j];
            }
            delete[] dynamicArray;
            dynamicArray = newArray;
            --size;
            return true;
        }
    }
    return false;
}

// returns the string at that index
std::string DynamicStringArray::getEntry(int findMe) const {
    return dynamicArray[findMe];
}

话虽如此,使用 astd::vector是首选的解决方案。它是一个动态大小的数组,可以为您包装new[]/ delete[]使用比直接使用new[]/更简单、更安全delete[],例如:

动态字符串数组.h

#pragma once
#include <string>
#include <vector>

class DynamicStringArray {
public:
    DynamicStringArray();
    DynamicStringArray(const std::string *array, int arraySize);

    int getSize() const;
    void addEntry(const std::string &newString);
    bool deleteEntry(const std::string &deleteMe);
    std::string getEntry(int findMe) const;

private:
    std::vector<std::string> dynamicArray; // dynamic array of type string
};

动态字符串数组.cpp

// DynamicStringArray.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "DynamicStringArray.h"
#include <algorithm>

// default constructor
DynamicStringArray::DynamicStringArray() {
}

// copy constructor that copies the array
DynamicStringArray::DynamicStringArray(const std::string *array, int arraySize) :
    dynamicArray(array, array + arraySize) {
}

// return number of entries in array
int DynamicStringArray::getSize() const {
    return dynamicArray.size();
}

// appends a new element to the end of the dynamic array
void DynamicStringArray::addEntry(const std::string &newString) {
    dynamicArray.push_back(newString);
}

// searches the dynamic array for a specific string,
// if string not found, return false
// if string is found, remove it and return true
bool DynamicStringArray::deleteEntry(const std::string &deleteMe) {
    std::vector<std::string>::iterator iter = std::find(dynamicArray.begin(), dynamicArray.end(), deleteMe);
    if (iter != dynamicArray.end())
    {
        dynamicArray.erase(iter);
        return true;
    }
    return false;
}

// returns the string at that index
std::string DynamicStringArray::getEntry(int findMe) const {
    return dynamicArray[findMe];
}

本文收集自互联网,转载请注明来源。

如有侵权,请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章

如何在不知道数组大小的情况下初始化数组?

如何在不将所有值归零的情况下初始化长Golang数组?

这段代码如何在不使用sizeof()的情况下确定数组大小?

在没有默认ctor的情况下初始化在类类型的#define中定义的大小的非静态成员数组

我如何在不初始化常量的情况下声明数组?

如何在不使用Python初始化新类的情况下编辑继承类的属性?

如何在没有空终止符的情况下初始化char数组?

在不使用指针的情况下,如何允许未初始化类类型的对象并确定何时是这种情况?

如何在不指定大小的情况下声明数组,而在C ++中的类内声明一个初始化器?

在C#中,调整数组大小(在这种情况下,增加大小)会使用默认值初始化新段-这样可靠吗?

如何在C ++中使用构造函数(只是构造函数)在类中初始化大型私有数组?

如何在不使用C#中的new关键字初始化变量的情况下用值填充数组变量?

如何在不使用分配的情况下访问类中的私有变量?

如何在不使用python初始化的情况下获取类对象的属性类型

如何在SwiftUI中不使用某些View {}的情况下初始化View?

如何在不使用'href'属性的情况下初始化jQuery UI Tabs?

如何在不使用匿名对象的情况下初始化列表初始值设定项中的对象?

默认情况下,如何在Java中声明/初始化数组?

如何在不使用现有Cookie的情况下初始化WKWebView

如何在不初始化的情况下声明反序列化的类参数数组?

在WPF应用程序中如何在没有主类的情况下初始化数据库(使用Entity Framework进行代码优先)

如何在不使用反射的情况下获取 php 类中的常量

如何在不使用 setter 的情况下从子类访问超类中的私有字段?

TypeScript:如何在不使用明确赋值断言的情况下使用 setter 初始化类的成员?

如何在运行时使用构造函数初始化类中私有的数组?

如何在Java中不初始化的情况下使用数组

如何在不使用数组的情况下在 for 循环中声明和初始化多个变量(具有不同名称)?

如何在不使用命名空间 chrono 的情况下初始化 std::chrono::duration 常量?

如何在我的条目不为空的情况下初始化我的数组?