如何修改指针指向的数组

How to modify array that pointer points to

本文关键字：数组 指针 何修改 修改      更新时间：2023-10-16

我需要向函数传递一个char指针，然后更改它在函数内部指向的值，并打印函数外部的值。

我遇到的问题是，当我离开功能并尝试在外面打印时，我会丢失它。我该怎么做才能避免这种情况？

这是一个代码示例：

    char array[] = "Bada boom";
    char *pText = array;
    reverseText(pText);
    cout << (pText);

cout应该打印

moob adaB

当我在函数内部打印时，一切都很好（打印相反）。我的任务是在功能之外打印出来（正如你在第4行代码中看到的）

这是有错误的完整代码（在func内部打印有效，在外部打印无效）

#include <iostream>
#include <string>
#include <string.h>
using namespace std;
char reverseText(char *text);
int main(){
    char array[] = "Bada boom"; 
    char *pTekst = array;

    reverseText(pTekst);
    cout << (pTekst);                 //in here it doesn't work
}
char reverseText(char *text){
    char befRev[100]; int lenght=-1;
    /*until *text doesn't meet '' */
    for(int i=0;*text!='';i++){
        befRev[i]=(*text);
        text++;
        lenght++;
    }
    /*reversing*/
    int j=0;
    for(int i=lenght;i>=0;i--){
        *(text+j)=befRev[i];
        j++;
    }
    for(int i=0;i<=lenght;i++)               //in here it does print the right value
        cout << text[i]; 
};

只需将数组重新排列到位。指针本身不需要更改：

#include <cstring>
#include <algorithm>
void reverseText(char* array)
{
  auto len = std::strlen(array);
  std::reverse(array, array+len);
}
int main()
{
  char array[] = "Bada boom";
  char *pText = array;
  reverseText(pText);
  std::cout << pText << std::endl;
}

输出：

moob-adaB-

如果你真的想为调用者提供一个指向不同地址的指针，你可以简单地返回它：

char* foo(char* stuff)
{
  char* tmp = ....;
  ...
  // do some stuff
  ...
  return tmp;
}

或者，您可以通过引用传递指针，但其意图不如前一版本中明确：

void foo(char*& stuff)
{
  stuff = something_else;
}

但在这两种情况下，必须绝对确保新指针指向的东西在函数之外是有效的。这可能需要一些动态内存分配。对于您的情况，最好和最简单的选择似乎是将阵列重新排列到位。

要回答您的问题，您在逻辑上有一个错误。请注意，在reverseText中的第一个循环中，您递增了本地指针文本。在第二个循环中，您没有将文本重置为其原始值，因此beforeRev将从位置text+偏移量开始复制。

如果你在调用reverseText返回时查看pText，你会发现它包含："Bada boom\0oob adaB"

您的reverseText应该重命名为回文：）

这非常简单。需要注意的几点：

  1. 当您将数组传递给函数时，数组会衰减为指针
  2. 您正在传递一个以null结尾的字符串。因此，您传入的char数组的长度是字符串的长度（包括空格）+1
  3. 因为您使用的是指针，所以不需要分配一个临时变量来保存所有内容

这里有一些C语言的代码，很容易翻译成C++。计算实际的反向算法留给你练习。

#include<stdio.h>
void reverseText(char* text)
{
    // Hint: It can be done in one loop!
    int i;
    for(i = 0; i < 9; i++)
    {
        // Your algorithm to reverse the text. I'm not doing it for you! ;)
        *(text + i) = 'r';
    }
}
int main()
{
    char array[] = "Bada boom";
    reverseText(array);
    printf("The text reversed: %sn", array);
    return 0;
}

我的最终代码：

#include <iostream>
void reverseText(char* text){   
    int length=-1; char tmp;
    /*Length = sign from 0 to 8 without counting explicit NUL terminator*/
    for(int i=0;*(text+i)!='';i++){   
        length++; 
    }
    int j=0; int i=length;
    while(j<i){
        tmp=*(text+j);          //tmp=first
        *(text+j)=*(text+i);    //first=last
        *(text+i)=tmp;          //last=tmp
        j++;
        i--;
    }
}
int main(){
    char array[] = "Bada boom"; 
    char *pText = array;
    reverseText(pText);
    std::cout << pText;
}

在开始这个练习之前，我应该多读一些关于指针的内容。

您可以返回指针，也可以将指针作为函数参数传递给指针。

//pointer to pointer
void reverseText(char** textPtr) {
    char* newText = ...; //initialize;
    ...
    *textPtr = newText;  //assign newText
}
//return pointer
char* reverseText(char* text) {
    char* newText = ...; //initialize
    return newText;
}

请记住，如果在该函数中分配内存，则必须动态分配（使用new或malloc），然后必须释放内存（分别使用delete或free）。像这样的函数中的内存分配可能是一种糟糕的做法，应该避免。

相关文章：