Почему «а»! = «А» в C?

void main() {
    if("a" == "a")
      printf("Yes, equal");  
    else
      printf("No, not equal");
}

Почему на выходе No, not equal?

Вы сравниваете два адреса памяти для разных строк, которые хранятся в разных местах. По сути, это выглядит так:

if(0x00403064 == 0x002D316A) // Two memory locations
{
    printf("Yes, equal");
}

Используйте следующий код для сравнения двух строковых значений:

#include <string.h>

...

if(strcmp("a", "a") == 0)
{
    // Equal
}

Кроме того, "a" == "a"действительно может возвращать истину, в зависимости от вашего компилятора, который может объединять одинаковые строки во время компиляции в одну для экономии места.

Когда вы сравниваете два символьных значения (которые не являются указателями), это числовое сравнение. Например:

'a' == 'a' // always true

Я немного опоздал на вечеринку, но все равно отвечу; технически те же биты, но с немного другой точки зрения (язык C ниже):

В языке C это выражение "a"обозначает строковый литерал , который является статическим безымянным массивом const char, длиной два - массив состоит из символов 'a'и '\0'- завершающий нулевой символ сигнализирует о конце строки.

Однако в C точно так же вы не можете передавать массивы функциям по значению - или присваивать им значения ( после инициализации ) - ==для массивов нет перегруженного оператора , поэтому сравнивать их напрямую невозможно. Рассматривать

int a1[] = {1, 2, 3};
int a2[] = {3, 4, 5};
a1 == a2 // is this meaningful? Yes and no; it *does* compare the arrays for
         // "identity", but not for their values. In this case the result
         // is always false, because the arrays (a1 and a2) are distinct objects

Если ==он не сравнивает массивы, что тогда он на самом деле делает? В C почти во всех контекстах, включая этот, массивы распадаются на указатели (которые указывают на первый элемент массива), и сравнение указателей на равенство делает то, что вы ожидаете. Так эффективно, делая это

"a" == "a"

вы фактически сравниваете адреса первых символов в двух безымянных массивах . Согласно стандарту C, сравнение может дать истинное или ложное значение (т.е. 1 или 0) - "a"s может фактически обозначать один и тот же массив или два совершенно не связанных массива. С технической точки зрения результирующее значение не указано , что означает, что сравнение разрешено (т. Е. Это не неопределенное поведение или синтаксическая ошибка), но любое значение является допустимым, и реализация (ваш компилятор) не требуется для документирования того, что на самом деле произойдет.

Как указывали другие, для сравнения «c-строк» ​​(т.е. строк, оканчивающихся нулевым символом) вы используете вспомогательную функцию, strcmpнайденную в стандартном файле заголовка string.h. Функция имеет возвращаемое значение 0для одинаковых строк; считается хорошей практикой явно сравнивать возвращаемое значение с 0вместо использования оператора `! ´, т.е.

strcmp(str1, str2) == 0 // instead of !strcmp(str1, str2)

Согласно C99 (Раздел 6.4.5 / 6)

Строковые литералы

Не указано, являются ли эти массивы различными, если их элементы имеют соответствующие значения .

Таким образом, в этом случае не указано, различны ли оба "a"s. Оптимизированный компилятор может хранить один "a"файл только для чтения, и обе ссылки могут относиться к нему.

Посмотрите вывод на gcc здесь

Потому что это 2 отдельных const char*указателя, без фактических значений. Вы говорите что-то вроде того, 0x019181217 == 0x0089178216что конечно возвращает НЕТ

Используйте strcmp()вместо==

Проще говоря, в C нет встроенного оператора сравнения строк. Таким образом нельзя сравнивать строки.

Вместо этого строки сравниваются с использованием стандартных библиотечных процедур, таких как strcmp (), или путем написания кода для циклического перебора каждого символа в строке.

В C строка текста в двойных кавычках возвращает указатель на строку. Ваш пример сравнивает указатели, и, очевидно, ваши две версии строки существуют по разным адресам.

Но это не сравнение самих струн, как вы, кажется, ожидаете.

Указатели.

Первый "a"- это указатель на строку ASCII с завершающим нулем.

Второй "a"- указатель на другую строку ASCII с завершающим нулем.

Если вы используете 32-битный компилятор, я бы ожидал "a"=="a"-4. Я только что попробовал с tcc / Win32, и у меня получилось "a"=="a"-2. Ну что ж...

Вы сравниваете два адреса памяти, поэтому результат не всегда будет правдой. Вы пробовали if('a' == 'a'){...}?

этот вопрос дает очень хорошее объяснение всем начинающим ....
позвольте мне также внести свой вклад в это .....

как все выше объясняли, почему вы получаете такой результат.

теперь если хочешь свою прогу. Чтобы вывести «да равно», тогда

либо использовать

if(strcmp("a", "a") == 0)
{

}

или
не используйте "a" как строки, используйте их как символы ....

if('a'=='a')  
{  
printf ("yes Equal");  
}  

в символах C - это короткое целое число размером 1 байт .......

В некоторых компиляторах есть опция «объединить строки», которую можно использовать, чтобы заставить все константные строки иметь один и тот же адрес. Если бы вы использовали это, "a" == "a"было бы true.

если сравнение между символами всегда в одинарных кавычках, например

if('a' == 'a')

и C не может поддерживать сравнение строк, например "abc" == "abc"

Это сделано с strcmp("abc","abc")

Этот парень не использует переменные. Вместо этого он временно использует текстовые массивы: aи a. Причина почему

void main() 
{
    if("a" == "a")
      printf("Yes, equal");  
    else
      printf("No, not equal");
}

не работает конечно, это то, что вы не сравниваете переменные.
Если бы вы создали такие переменные, как:

char * text = "а";
char * text2 = "а";

то вы могли бы сравнить textс text2, и это должно быть правдой

Может не стоит забывать использовать {и }=)

void main() {
    if("a" == "a")
    {
      printf("Yes, equal");
    }
    else
    {
      printf("No, not equal");
    }
}