C++ 如何避免在类中返回指针

假设我有一个类a，它有3个方法。因此，第一个方法将一些值分配给第一个数组，其余的方法将修改前一个方法计算的值。因为我想避免设计返回数组（指向局部变量的指针）的方法，所以我选择了3个数据成员，并将中间结果存储在每个方法中。请注意，此简单代码用于说明

class A
{
public: // for now how the class members should be accessed isn't important 
int * a, *b, *c;

A(int size)
{
    a = new int [size];
    b = new int [size];
    c = new int [size];
}

void func_a()
{ 
    int j = 1;

    for int(i = 0; i < size; i++)
        a[i] = j++;   // assign different values
}

void func_b()
{
    int k = 6;

    for (int i = 0; i < size; i++)
        b[i] = a[i] * (k++);
}

void func_c()
{
    int p = 6;

    for int (i = 0; i < size; i++)
        c[i] = b[i] * (p++);
}
};

A类
{
public://目前，如何访问类成员并不重要
int*a、*b、*c；
A（整数大小）
{
a=新的整数[大小]；
b=新的整数[大小]；
c=新整型[尺寸]；
}
void func_a（）
{ 
int j=1；
对于int（i=0；i

显然，如果我有更多的方法，我就必须有更多的数据成员

---

**我想知道如何重新设计该类（具有返回一些值的方法），同时，该类没有两个问题中的任何一个（返回指针和有许多数据成员来存储中间值）

我假设您希望能够修改没有类级属性且不返回任何指针的单个数组。您的上述代码可以修改为单个函数，但我将其保留为3，以便与您的代码更紧密地匹配

void func_a(int[] arr, int size){
    for(int i = 0; i < size; i++)
        arr[i] = i+1;
}

void func_b(int[] arr, int size){
    int k = 6;
    for(int i = 0; i < size; i++)
        arr[i] *= (k+i);
}

//this function is exactly like func_b so it is really unnecessary
void func_c(int[] arr, int size){
    int p = 6;
    for(int i = 0; i < size; i++)
        arr[i] *= (p+i);
}

void func_a（int[]arr，int size）{
对于（int i=0；i

但如果您只需要一个函数：

void func(int[] arr, int size){
    int j = 6;
    for(int i = 0; i < size; i++)
        arr[i] = (i+1) * (j+i) * (j+i);
}

void func（int[]arr，int size）{
int j=6；
对于（int i=0；i

有两种可能性。如果希望每个函数返回一个新的值数组，可以编写以下代码：

std::vector<int> func_a(std::vector<int> vec){
    int j = 1;
    for (auto& e : vec) {
        e = j++;
    }
    return vec;
}
std::vector<int> func_b(std::vector<int> vec){      
    int j = 6;
    for (auto& e : vec) {
        e *= j++;
    }
    return vec;     
}
std::vector<int> func_c(std::vector<int> vec){
    //same as func_b
}
int main() {
    std::vector<int> vec(10);
    auto a=func_a(vec);
    auto b=func_b(a);
    auto c=func_c(b);
    //or in one line
    auto r = func_c(func_b(func_a(std::vector<int>(10))));
}

std:：vector func_a（std:：vector vec）{
int j=1；
用于（自动和电气：vec）{
e=j++；
}
返回向量；
}
std:：vector func_b（std:：vector vec）{
int j=6；
用于（自动和电气：vec）{
e*=j++；
}
返回向量；
}
标准：：向量函数（标准：：向量向量）{
//与func_b相同
}
int main（）{
std:：vec（10）；
自动a=功能a（vec）；
自动b=函数b（a）；
自动c=函数c（b）；
//还是一行
自动r=func_c（func_b（func_a（std:：vector（10）））；
}

也可以将每个函数应用于同一向量：

void apply_func_a(std::vector<int>& vec){
    int j = 1;
    for (auto& e : vec) {
        e = j++;
    }
}
void apply_func_b(std::vector<int>& vec){
    int j = 6;
    for (auto& e : vec) {
        e *= j++;
    }
}
void apply_func_c(std::vector<int>& vec){
    // same as apply_func_b 
}

int main() {
    std::vector<int> vec(10);
    apply_func_a(vec);
    apply_func_b(vec);
    apply_func_c(vec);
}

void apply_func_a（标准：：向量和向量）{
int j=1；
用于（自动和电气：vec）{
e=j++；
}
}
无效应用函数（标准：：向量和向量）{
int j=6；
用于（自动和电气：vec）{
e*=j++；
}
}
无效应用函数（标准：：向量和向量）{
//与应用函数相同
}
int main（）{
std:：vec（10）；
应用函数a（vec）；
应用函数b（vec）；
应用函数c（vec）；
}

我不太喜欢第三个版本（将输入参数作为输出传递）：

std:：vector和func_a（std:：vector和vec）

---

最重要的是，尽量避免使用C型数组，使用

std:：vector

或

std:：array

，不要使用

new

，而是

std:：make_unique

和

std:：make_shared

其他答案中的这个解决方案更好，如果要分配内存，那么就这样做（并测试！）另外，如果您没有使用默认构造函数和复制构造函数，那么就隐藏它们，这将防止意外调用它们

class A{
private:
A(const &A){}
A() {}//either define these or hide them as private
public: 
    int * a, *b, *c;
    int size;
    A(int sz) {
        size = sz;
        a = new int[size];
        b = new int[size];
        c = new int[size];
    }
    ~A()
    {
        delete[]a;
        delete[]b;
        delete[]c;
    }
//...
};

---

这不是在创建数组

a=new int（size）

@EdHeal谢谢我编辑了它。你的代码不会返回任何指针。如果您不想将中间值存储为类成员，请不要这样做。你能描述一下你们班想要达到的目标吗？如果你只想做一系列的计算，你可以在function@Adrian如果

b

或

c

未能在构造函数中分配内存，则表示内存泄漏。此代码不可编译，不需要编译。j被添加到i中，i是递增的。我发现它可以简化为一个表达式，但看起来并不简单<代码>arr[i]=i*i*i+13*i*i+48*i+36

class A{
private:
A(const &A){}
A() {}//either define these or hide them as private
public: 
    int * a, *b, *c;
    int size;
    A(int sz) {
        size = sz;
        a = new int[size];
        b = new int[size];
        c = new int[size];
    }
    ~A()
    {
        delete[]a;
        delete[]b;
        delete[]c;
    }
//...
};