所以我有一个部分填充的阵列，我正试图找到最大的数字。我老师给我们的所有工具只能使用完全填充的数组，所以我迷失在这里。
我的阵列是平行的。一个是双数组（但在查看时保持输出int - 稍后我会问这个），另一个是字符串。
我们必须在控制台艺术中显示信息。这就是为什么我必须找到最大的，所以我们可以生成一个不会太大或太小的屏幕。最大的数字当然是艺术最大的一个，其余的将根据大的数字来计算。
这是我的功能：
int findLargest(double sales[])
{
int indexOfLargest = 0;
for (int i = 0; i < 100; i++)
{
if (sales[i] > sales[indexOfLargest])
indexOfLargest = i;
}
return indexOfLargest;
}
以下是主要内容的一部分：
double sales[100];
string names[100];
int elementNumber = 0;
elementNumber = findLargest(sales);
cout << "largest element number is " << elementNumber << endl;
当我运行此代码来测试它时，它输出具有最大数字的数组具有78的索引，即使我有一个条目因此它应该是0.非常混淆老实说，任何全面的资源都会很棒。
编辑：这被保存到文本文件中，必须重复使用。
另一个编辑： 现在我可以获得阵列的大小！ Yipee！但是你找到最大的一个（通过使用大小）的所有建议都不适合我。
这是我目前的主要代码段
string fileName = "";
int size = 0;
int indexOfLargest = 0;
indexOfLargest = findLargest(sales, size, fileName);
这是功能：
int findLargest(double sales[], int &sz, string fileName)
{
double numbers = 0;
string names;
int indexOfLargest = 0;
ifstream fin(fileName.c_str());
if (fin)
{
cout << "file opened" << endl;
while (isalnum(fin.peek()))
{
getline(fin, names);
fin >> numbers;
fin.ignore(5, '\n');
sz++;
}
cout << "The size is " << sz << endl;
//size = 4
if (sz == 0) return -1; // no data means no highest index
for (int i = 0; i < sz; ++i)
{
if (sales[i] > sales[indexOfLargest])
indexOfLargest = i;
}
cout << "Index: " << indexOfLargest;
fin.close();
}
return indexOfLargest;
再次感谢您为此付出时间。我的伴侣和我很困惑。我想到有些人在两个小时内完成了这项工作。
答案 0 :(得分：2)
数组具有大小，并且所有元素存在于数组中。除非您将自己的限制（和代码）强加给它们，否则没有部分填充的数组。
所以，如果通过部分填充，你只是意味着你只使用（例如）那100个数组元素中的前十个，你只需要将你的支票限制在那个区域，例如：
int findLargest(double sales[], int sz) {
if (sz == 0) return -1; // no data means no highest index
int indexOfLargest = 0;
for (int i = 1; i < sz; i++)
if (sales[i] > sales[indexOfLargest])
indexOfLargest = i;
return indexOfLargest;
}
当然，这意味着您需要与arrray一起保持大小：
double sales[100];
int sz = 0;
sales[sz++] = 3.141592653589;
sales[sz++] = 2.718281828459;
int highIdx = findLargest (sales, sz);
例如，这是一个测试程序，它使用一个大数组buff并在该数组上强加额外的信息sz：
#include <stdio.h>
int main (void) {
char buff[1000];
int sz = 0;
buff[sz++] = '3'; buff[sz++] = '.'; buff[sz++] = '1';
buff[sz++] = '4'; buff[sz++] = '1'; buff[sz++] = '5';
printf ("Buffer size is %d\n", sizeof (buff));
printf ("Buffer used is %d\n", sz);
printf ("Buffer is ");
for (int i = 0; i < sz; i++)
putchar (buff[i]);
putchar ('\n');
return 0;
}
输出结果为：
Buffer size is 1000
Buffer used is 6
Buffer is 3.1415
也许更适用的代码是：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int findLargest(double sales[], int sz) {
if (sz == 0) return -1;
int indexOfLargest = 0;
for (int i = 1; i < sz; i++)
if (sales[i] > sales[indexOfLargest])
indexOfLargest = i;
return indexOfLargest;
}
#define SZ 15
int main (void) {
double sales[SZ];
int sz = 0;
srand (time (NULL));
for (int i = 0; i < SZ; i++)
sales[i] = 9999.99;
for (int i = 0; i < 10; i++)
sales[sz++] = (float)(rand() % 10000) / 100;
printf ("Array size is: %d\n", sizeof (sales) / sizeof (*sales));
printf ("Array used is: %d\n", sz);
printf ("Array is:\n");
for (int i = 0; i < SZ; i++)
printf (" %2d: %8.2f%s\n", i, sales[i], (i < sz) ? "" : " - unused");
printf ("Highest value at index: %d\n", findLargest (sales, sz));
return 0;
}
，对于几次测试运行，它会向您显示正在运行的功能：
Array size is: 15
Array used is: 10
Array is:
0: 22.66
1: 10.66
2: 63.28
3: 41.05
4: 22.50
5: 78.05
6: 56.96
7: 21.48
8: 21.69
9: 98.77
10: 9999.99 - unused
11: 9999.99 - unused
12: 9999.99 - unused
13: 9999.99 - unused
14: 9999.99 - unused
Highest value at index: 9
（看到索引9是最高值98.77）和
Array size is: 15
Array used is: 10
Array is:
0: 93.56
1: 94.28
2: 38.54
3: 36.54
4: 20.90
5: 38.39
6: 15.02
7: 5.18
8: 67.72
9: 17.09
10: 9999.99 - unused
11: 9999.99 - unused
12: 9999.99 - unused
13: 9999.99 - unused
14: 9999.99 - unused
Highest value at index: 1
（索引1是最高值94.28）。
答案 1 :(得分：0)
另一种选择是使用vector而不是array。每当您需要添加元素时，请使用push_back方法将其附加到矢量。然后，您可以按如下方式重写findLargest函数：
int findLargest(vector<double>& sales)
{
int indexOfLargest = 0;
for (int i = 0; i < sales.size(); i++)
{
if (sales[i] > sales[indexOfLargest])
indexOfLargest = i;
}
return indexOfLargest;
}
编辑：根据我的理解，您面临的主要困难是您不知道阵列的大小是多少，因此，您最终会分配额外的空间。如上所述，使用向量可以帮助您克服这个问题。当你将元素推入它时它会动态调整大小。而且您不必担心跟踪阵列的实际大小。
答案 2 :(得分：0)
你应该能够通过以下方式传递数组的大小：
int GetLargestElementByIndex(double sales[], size_t size)
{
int index = 0;
for (int i = 0; i < size; ++i)
{
if (sales[i] > sales[index])
index = i;
}
return index;
}
将会这样称呼：
double sales[8] = { 5.5, 2.2, 1.8, 6.6, 9.3, 14.0, 3.5, 9.2 };
int largestIndex = GetLargestElementByIndex(sales, 8);
但是，您也可以使用模板：
// Because we are using a template, this can be used with any array that has operator > declared for it, rather than restricting its use for an int or double
// Type = the type of the object (e.g. int, double, std::string). This is implicitly deduced from the array passed in
// size = this is the size of the array implicitly determined by the array passed in
template <typename Type, size_t size>
int GetLargestElementByIndex(const Type (&arrayOfType)[size]) // pass a const reference as we do not need to modify this object
{
int index = 0;
for (int i = 0; i < size; ++i)
{
if (arrayOfType[i] > arrayOfType[index])
index = i;
}
return index;
}
这就像上面这样调用，但不需要传递大小，它可以使用更多类型，而不仅仅是双打：
double sales[] = { 2.2, 3.3, 1.0, -1.5, 5.9, 6 };
int largestIndex = GetLargestElementByIndex(sales);
int wholeSales[] = { 19, 33, 1, -4, -100, 60 };
largestIndex = GetLargestElementByIndex(wholeSales);
答案 3 :(得分：0)
最简单的方法是在输入时跟踪最大值：
double sales[100];
string names[100];
int num_entries = 0;
size_t max_sales_index = 0;
while (num_entries < sizeof(sales) / sizeof(sales[0]) &&
std::cin >> sales[num_entries] &&
getline(std::cin, names[num_entries]))
{
if (sales[num_entries] > sales[max_sales_index])
max_sales_index = num_entries;
++num_entries;
}
cout << "largest element number is " << max_sales_index << endl;
此代码跟踪num_entries中输入的元素数量。有了这个号码，你可以打电话给＆＃34;找到最大的＆＃34;功能，但为什么要打扰？