char* names[]={"A", "B", "C"};
有没有办法找到数组中的字符串数量。例如，在这种情况下，它必须是3.请让我知道。感谢。
答案 0 :(得分：31)
在这种情况下，您可以将总大小除以第一个元素的大小：
num = sizeof(names) / sizeof(names[0]);
但是要小心，这适用于数组。它不适用于指针。
答案 1 :(得分：23)
对于一个数组，即赏金中的例子，执行sizeof(names)/sizeof(names[0])就足以确定数组的长度。
示例中的字符串长度不同并不重要。 names是char *的数组，因此数组的总大小（以字节为单位）是数组中元素的数量乘以每个元素的大小（即char *）。这些指针中的每一个都可以指向任何长度的字符串，或者指向NULL。没关系。
测试程序：
#include<stdio.h>
int main(void)
{
char* names1[]={"A", "B", "C"}; // Three elements
char* names2[]={"A", "", "C"}; // Three elements
char* names3[]={"", "A", "C", ""}; // Four elements
char* names4[]={"John", "Paul", "George", "Ringo"}; // Four elements
char* names5[]={"", "B", NULL, NULL, "E"}; // Five elements
printf("len 1 = %zu\n",sizeof(names1)/sizeof(names1[0]));
printf("len 2 = %zu\n",sizeof(names2)/sizeof(names2[0]));
printf("len 3 = %zu\n",sizeof(names3)/sizeof(names3[0]));
printf("len 4 = %zu\n",sizeof(names4)/sizeof(names4[0]));
printf("len 5 = %zu\n",sizeof(names5)/sizeof(names5[0]));
}
输出：
len 1 = 3
len 2 = 3
len 3 = 4
len 4 = 4
len 5 = 5
编辑：
为了澄清，这只适用于您定义了一个数组，即char *names[]或char names[][]，并且您位于定义数组的范围内。如果它被定义为char **names，那么你有一个指针作为一个数组，上面的技术将不起作用。类似地，如果char *names[]是一个函数参数，在这种情况下，数组会衰减到第一个元素的地址。
答案 2 :(得分：14)
这取决于数组的创建方式。在C中，没有办法检查作为指针的数组的长度，除非它有一个sentinel元素，或者一个整数与数组一起传递作为数组中元素的计数。在您的情况下，您可以使用此：
int namesLen = sizeof(names) / sizeof(char);
但是，如果您的数组是指针，
char **names = { "A", "B", "C" };
您可以拥有一个对于数组长度为常量的整数：
int namesLen = 3;
或添加标记值（例如NULL）
char **names = { "A", "B", "C", NULL };
int namesLen = -1;
while (names[++namesLen] != NULL) { /* do nothing */}
// namesLen is now the length of your array
另一种方法是，您可以创建一个充满所需值的结构：
struct Array {
void **values;
int length;
};
#define array(elements...) ({ void *values[] = { elements }; array_make(values, sizeof(values) / sizeof(void *)); })
#define destroy(arr) ({ free(arr.values); })
struct Array array_make(void **elements, int count)
{
struct Array ret;
ret.values = malloc(sizeof(void *) * count);
ret.length = count;
for (int i = 0; i < count; i++) {
ret.values[i] = elements[i];
}
return ret;
}
你会这样使用它：
struct Array myArray = array("Hi", "There", "This", "Is", "A", "Test");
// use myArray
printf("%i", myArray.length);
destroy(myArray);
答案 3 :(得分：7)
你在这里定义的并不是字符串数组，它是指向字符的指针数组。如果你想知道字符串的数量，你只需要计算指针，所以像
size_t size = sizeof(names)/sizeof(char*);
会这样做，这样你就可以将数组的大小除以单个指针的大小。但是要注意，只有在编译时已知数组的大小（即数组已分配）静态地），如果它是动态定义的（即char **字符串），则sizeof(strings)将返回指针的大小而不是数组。
p.s.:字符串的长度是不相关的，因为数组甚至不知道＆＃34;意识到＆＃34;指针指向的是什么。
答案 4 :(得分：2)
int count = sizeof(names)/sizeof(*names);
这需要names的总大小，并将其除以names中一个元素的大小，得到3。
答案 5 :(得分：1)
有没有办法找到数组中的字符串数
当然有，试试这个：
#include<stdio.h>
int main(void){
size_t size, i=0;
int count=0;
char* names[]={"A", "B", "C"};
size = sizeof(names)/sizeof(char*);
for(i=0;i<size;i++){
printf("%d - %s\n",count+1, *(names+i));
count++;
}
printf("\n");
printf("The number of strings found are %d\n",count);
return 0;
}
1 - A 2 - B 3 - C
The number of strings found are 3
同样的事情：
#include<stdio.h>
int main(void){
size_t size, i=0;
int count=0;
char *names[]={"Jimmy", "Tom", "Michael", "Maria", "Sandra", "Madonna"};
size = sizeof(names)/sizeof(char*);
for(i=0;i<size;i++){
printf("%d - %s\n",count+1, *(names+i));
count++;
}
printf("\n");
printf("The number of strings found are %d\n",count);
return 0;
}
输出：
1 - Jimmy 2 - Tom 3 - Michael 4 - Maria 5 - Sandra 6 - Madonna
The number of strings found are 6
或使用这样的函数：
#include<stdio.h>
size_t arrLength(size_t len, char **arr){
size_t i=0;
size_t count=0;
for(i=0;i<len;i++){
printf("%zu - %s\n",count+1, *(arr+i));
count++;
}
return count;
}
int main(void){
char *names[]={"Jimmy", "Tom", "Michael", "Maria", "Sandra", "Madonna"};
size_t length,size;
size = sizeof(names)/sizeof(char*);
length = arrLength(size, names);
printf("\n");
printf("The number of strings found are %zu\n",length);
return 0;
}
输出：
1 - Jimmy 2 - Tom 3 - Michael 4 - Maria 5 - Sandra 6 - Madonna
The number of strings found are 6
答案 6 :(得分：0)
返回数组中的数字或字符串的一种简单方法是迭代数组，直到用完字符串。这是一个例子。
#include <stdio.h>
int main()
{
char* names[] = {"John", "Paul", "George", "Ringo", '\0'};
int size = 0;
while(names[++size]!='\0');
printf("Size: %d\n", size); // Prints "4"
return 0;
}
这种方法的优点是即使字符串长度不一样也可以。注意names数组中的终止NULL字节，以及;字符关闭while语句，因为没有要运行的语句体。
答案 7 :(得分：0)
在C
中查找字符串数组中的字符串数
查找数组中对象数的简单方法是将数组的大小除以其中一个元素的大小。使用sizeof运算符返回对象的大小（以字节为单位）。
// For size_t
#include <stddef.h>
char* names[] = { "A", "B", "C" };
size_t number_of_strings = sizeof names / sizeof names[0];
printf("Number of strings %zu\n", number_of_strings);
重要的是要考虑从sizeof返回的类型是size_t，这是一种无符号整数类型，能够索引任何数组以及任何对象的大小。要打印size_t类型的变量，请使用修饰符z。
答案 8 :(得分：0)
下面的答案是什么
class MainActivity : AppCompatActivity() {
companion object {
const val UPDATE_REQUEST_CODE = 112
const val TAG = "MainActivity"
}
private var appUpdateManager: AppUpdateManager? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<TextView>(R.id.tv_text).text = "Version " + BuildConfig.VERSION_NAME
// Returns an intent object that you use to check for an update.
appUpdateManager = AppUpdateManagerFactory.create(this)
}
private val listener: InstallStateUpdatedListener =
InstallStateUpdatedListener { installState ->
if (installState.installStatus() == InstallStatus.DOWNLOADED) {
// After the update is downloaded, show a notification
// and request user confirmation to restart the app.
Log.d(TAG, "An update has been downloaded")
} else if (installState.installStatus() == InstallStatus.INSTALLED) {
Log.d(TAG, "An update has been installed")
}
}
override fun onStart() {
super.onStart()
checkAppVersionNew()
}
private fun checkAppVersionNew() {
val appUpdateInfoTask = appUpdateManager!!.appUpdateInfo
appUpdateInfoTask.addOnSuccessListener { result: AppUpdateInfo ->
if (result.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE && result.isUpdateTypeAllowed(
AppUpdateType.IMMEDIATE
)
) {
try {
Log.d(TAG, "An update available")
appUpdateManager!!.startUpdateFlowForResult(
result,
AppUpdateType.IMMEDIATE,
this,
UPDATE_REQUEST_CODE
)
} catch (e: SendIntentException) {
Log.d(TAG, "SendIntentException $e")
e.printStackTrace()
}
}
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
if (requestCode == UPDATE_REQUEST_CODE) {
when (resultCode) {
RESULT_OK -> {
Log.d(TAG, "Update success")
}
RESULT_CANCELED -> {
Log.d(TAG, "Update cancelled")
}
ActivityResult.RESULT_IN_APP_UPDATE_FAILED -> {
Log.d(TAG, "Update failed")
}
}
}
}
}
我得到 1
答案 9 :(得分：-3)
使字符串数组在带有增量运算符的循环中运行，直到循环变为 NULL ，才给出数组大小：
#include<stdio.h>
char* names[]={"A", "B", "C"};
int main(){
int nameSize = 0;
while(names[++nameSize]!='\0');
}
for(i=0;i<nameSize;i++){
printf("%s\n", names[i]);
}
return 0;
}
输出：
A
B
C