Question

我想知道是否可以交换两个不同大小的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本身的引用，将数据存储在临时变量中，删除分配给它们的内存，并使用交换的数据将它们链接到新创建的数组。我认为这将避免预定义的内存限制。但是，似乎非常不允许将引用（＆amp;）传递给数组。

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

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

Answer 1

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);

如果你的书在std::string之前教授C风格字符串，你应该考虑getting a new book。

Answer 2

只要数组是固定大小，就允许引用数组。

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

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

什么可以更容易？

另外，向量是你的问题的答案，'而且，是否可以在不预先确定大小的情况下用C ++创建一个新数组？'。你可以创建一个向量，然后再调整大小（这几乎是一样的）。

Answer 3

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

#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数组;而你所看到的是它的视觉表现（因为代码将它作为一个角色打印出来）。

是否可以在C ++中交换任意大小的数组？

3 个答案: