1

我想知道是否可以交换两个不同大小的 C++ 数组的内容（不使用任何预定义的 C++ 函数）？我的代码如下：

#include <iostream>
#include <string>

using namespace std;  

void swapNames(char a[], char b[])
{

    //can be done with one temp; using two for clarity purposes 
    char* temp = new char[80];
    char* temp2 = new char[80];
    int x = 0;

    while(*(b+x)!='\0')
    {
        *(temp+x) = *(b+x);
        x=x+1;
    }

    x=0;
    while(*(a+x)!='\0')
    {
        *(temp2+x) = *(a+x);
        x=x+1;
    }

    x=0;    
    while(*(temp2+x)!='\0')
    {
        *(b+x) = *(temp2+x);
        x=x+1;
    }

    x=0;
    while(*(temp+x)!='\0')
    {
        *(a+x) = *(temp+x);
        x=x+1;
    }
}

int main()
{
    char person1[] = "James";
    char person2[] = "Sarah";

    swapNames(person1, person2);

    cout << endl << "Swap names..." << endl;
    cout << endl << "Person1 is now called " << person1;

    cout << "Person2 is now called " << person2 << endl;;
}

我最初的想法是自己传递对 person1 和 person2 的引用，将数据存储在临时变量中，删除分配给它们的内存，并将它们链接到带有交换数据的新创建的数组。我认为这将避免预定义的内存限制。但是，似乎非常不允许将引用（&）传递给数组。

如果 person1 和 person2 的大小相同，则上述工作正常。但是，一旦我们有不同大小的名称，我们就会遇到问题。我认为这是因为我们无法更改最初创建 person1 和 person2 时分配的内存块。

另外，是否可以在不预先定义大小的情况下在 C++ 中创建一个新数组？IE 一种创建临时变量而不限制其大小的方法。

4

3 回答 3

5 
char person1[] = "James";

只是以下的简写：

char person1[6] = "James";

您以后不能在 person1 中存储超过 6 个字符。如果您真正想要的是不同长度的字符串，我建议放弃 C 风格的字符串以支持std::string标准库类型：

#include <string>
#include <algorithm>

std::string person1 = "James";
std::string person2 = "Sarah";

swap(person1, person2);

如果你的书在 s 之前教授 C 风格的字符串std::string，你应该考虑买一本新书。

于 2012-10-14T14:25:48.440 回答
1

只要数组是固定大小的，就可以引用数组。

有一个简单的答案，而不是您正在考虑的所有复杂事物。只需使用一个向量。

vector<char> a;
vector<char> b;
...
a.swap(b);

还有什么比这更容易的？

向量也是您问题的答案，“另外，是否可以在不预先定义大小的情况下在 C++ 中创建一个新数组？”。您可以创建一个矢量，然后稍后调整它的大小（这几乎是同一件事）。

于 2012-10-14T14:35:19.620 回答
0

您应该始终更喜欢容器类而不是原始数组。但是，如果您绝对必须使用数组，您当然可以完成交换，而无需诉诸于动态分配临时数组。使用模板静态确定传递给交换函数的数组的类型和大小。

#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>

template<typename T, size_t N>
void swap_arrays( T(&left)[N], T(&right)[N] )
{
  T temp[N];

  // copy left to temp
  std::copy( std::begin(left), std::end(left), std::begin(temp) );
  // copy right to left
  std::copy( std::begin(right), std::end(right), std::begin(left) );
  // copy temp to right
  std::copy( std::begin(temp), std::end(temp), std::begin(right) );
}

template<typename T, size_t N>
void swap_and_print( T(&left)[N], T(&right)[N] )
{
  std::cout << "\nBefore swapping: \n";

  std::cout << "  Left:";
  std::for_each( std::begin(left), std::end(left), 
                 []( T const& t ) { std::cout << " " << t; } );
  std::cout << "\n  Right:";
  std::for_each( std::begin(right), std::end(right), 
                 []( T const& t ) { std::cout << " " << t; } );

  swap_arrays( left, right );

  std::cout << "\nAfter swapping: \n";

  std::cout << "  Left:";
  std::for_each( std::begin(left), std::end(left), 
                 []( T const& t ) { std::cout << " " << t; } );
  std::cout << "\n  Right:";
  std::for_each( std::begin(right), std::end(right), 
                 []( T const& t ) { std::cout << " " << t; } );
}

int main()
{
  int foo1[] = {1,2,3,4,5};
  int bar1[] = {6,7,8,9,10};

  swap_and_print( foo1, bar1 );

  char foo2[] = "James";
  char bar2[] = "Sarah";

  swap_and_print( foo2, bar2 );
}

输出：

Before swapping: 
  Left: 1 2 3 4 5
  Right: 6 7 8 9 10
After swapping: 
  Left: 6 7 8 9 10
  Right: 1 2 3 4 5
Before swapping: 
  Left: J a m e s �
  Right: S a r a h �
After swapping: 
  Left: S a r a h �
  Right: J a m e s �

注意：第二个示例末尾的奇怪字符是因为输入是char包含终止空字符的数组；您所看到的是它的视觉表示（因为代码将其打印为字符）。

于 2012-10-14T15:25:37.450 回答