＃包括struct temp{ unsigned int zero_bit : 1; unsigned int first_bit : 1;}; // struct temp_1{// unsigned int zero_bit : 0;// unsigned int

#include <stdio.h>
        
struct temp{
    unsigned int zero_bit : 1;
    unsigned int first_bit : 1;
};
        
//   struct temp_1{
//       unsigned int zero_bit : 0;
//       unsigned int first_bit : 0;
//   } ;    // Code fails
       
int main() {
     
    struct temp a1;
    printf("%d", a1.zero_bit); // returns 0
        
    return 0;
}

为什么会 struct temp1 失败而不会 struct temp ，考虑到它们都被初始化为 0。

为什么编译器给我一个错误的希望，认为它 zero_bit 已被初始化为值 1，而实际上它已被初始化为值 0？

我是一名 C 语言程序员新手。我定义了两个变量 int x = 0xffffffff 和 char y = x，然后使用 printf(\'%x\n\', y) 函数将其打印出来；我期望得到类似 ff 的内容...

我是一名 C 语言程序员新手。我定义了两个变量 int x = 0xffffffff 和 char y = x ，然后使用函数打印了它们 printf("%x\n", y) ；我原本期望 ff 在终端上看到类似的东西，但它却打印 ffffffff 在屏幕上。我想知道当 char 的存储大小为 1 时，如何 char 存储 4 个字节的存储空间。

#include <stdio.h>

int main(void) {
    int x = 0xffffffff;
    char y = x;
    printf("%x\n", y);

    return 0;
}

后面的数字 ： 不是初始化值，而是 位域 宽度 （以位为单位） :

位字段
声明一个具有明确宽度（以位为单位）的成员。相邻的位字段成员可以打包以共享和跨越各个字节。

标识符 _（可选）： 宽度

另请参阅上面的文档链接：

宽度 -
一个整数常量表达式，其值大于或等于零，小于或等于基础类型的位数。当大于零时，这是此位字段将占用的位数。 值零仅适用于无名位字段，并且具有特殊含义： 它指定类定义中的下一个位字段将从分配单元的边界开始。

（重点是我的）

在 struct temp 的宽度 1 是有效的，但是在 struct temp_1 的宽度 0 是无效的（它不属于上面提到的无名位域的例外）。
这是编译错误的原因 struct temp_1 .

另一个问题是在这些行中：

struct temp a1;
printf("%d", a1.zero_bit); // returns 0

a1 未初始化，因此包含不确定的值。 0 您看到的值只是偶然的。

这里实际上发生了很多事情。首先：

int x = 0xffffffff;

整型常量 0xffffffff 的值为 4,294,967,295（即 2³²-1），类型为 unsigned int ，假设 int 为 32 位。

将此 unsigned int 值转换为 int 以进行初始化。这将经历实现定义的转换，在大多数情况下会导致赋值为 -1。此值恰好与原始值的二进制补码表示形式相同。

然后在这一行：

char y = x;

我们 y 用值 -1 进行初始化。此值在 a 的范围内 char （假设 char 为 int 时值没有变化 char 。假设使用二进制补码表示，则表示为 0xff .

然后当你打印时：

printf("%x\n", y);

由于 printf ，具有类型的 y 参数 char 会 被提升为 类型 int 。与之前一样，两种类型都可以存储值 -1，因此该值不变。

格式 %x 说明符需要一个类型为 的参数 unsigned int 。由于 int 传递的是 而不是 ，因此从 unsigned int 技术上讲，这是未定义的行为，但是有符号/无符号不匹配不太可能在任何实际实现中导致问题。

在这种情况下， int -1 的值具有一个表示， 0xffffffff 当将其解释为 unsigned int 将具有该值时， ffffffff 打印的内容也是如此。

因此回答你的问题：

当字符的存储大小为 1 时，字符如何存储 4 个字节的存储空间。

事实并非如此。它只是由于相关类型的转换和表示而显得如此。

假设使用二进制补码表示，则表示为 0xff。恐怕这部分仍然有点令人困惑：如果 char 是有符号的，则值为 -1，在使用二进制补码表示的系统中，该值存储在一个所有位都置位的字节中。调试器将显示字节值 FF，但由于整数提升规则（如前所述），printf 将输出 ffffffff。

int x = 0xffffffff; 是实现定义的行为，因为 0xFFFFFFFF 系统中 2^31-1 大于 int 和 char 的大小 int 都是实现定义的。

它的实现定义为如果 char 是 signed 或 unsigned ：

• p2

• p3

格式说明 %x 符需要， unsigned int 因此您确实应该在打印之前将其转换为明确定义的行为。无论哪种情况 %x 都不会生成 0x 前缀并输出小写字母。

您可能还会提到在 32 位系统上 int x = 0xffffffff; 中的实现定义行为。此外，输出将不包含 0x 前缀，也不会对 f 十六进制数字使用大写字母。为了完整起见，该代码也可能适用于 char 无符号且具有 32 位的平台，并且将输出 ffffffff，并且如果 int 类型具有 32 个或更多的值位，则绝对应该如此。

@chqrlie 已按建议修改（如果我遗漏了什么，请再次提醒我）。如果我执行 unsigned char y = x，gcc 将返回结果 ff。您有其他参考资料吗？

我提到的情况非常极端：无符号字符的位数由实现定义。它必须至少为 8，并且在大多数当前平台上正好为 8，因此如果字符是无符号的，则在这些平台上输出为 ff，但在具有较大字符类型的某些 DSP 上，输出可能是 ffff 甚至 ffffffff。

@chqrlie 谢谢。也澄清了那部分。保留评论，因为它是有用的上下文，但完整的细节使答案变得混乱。

下面是 Arduino 应该做什么的描述，但是我发现在主程序中的第一个循环之后，引脚没有再次激活：mainRoutine 函数从 t 中检索当前时间......

下面是 Arduino 应该做什么的描述，但是我发现在主程序中第一次循环之后，引脚没有再次激活：

mainRoutine 函数从 RTC 获取当前时间。如果当前时间在上午 6 点到下午 5 点之间，它会按顺序触发每个继电器模块，从而控制电动阀。如果当前日期是奇数日，它会暂停 4 小时，然后再次触发连接到 pin8 的继电器。在所有继电器模块都触发后，它会计算到下一个上午 6 点的延迟时间并等待该持续时间。

以下是逻辑实现：

#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
const int dayStart = 6;
const int dayEnd = 17; 
const int pin8 = 8;
const int pin7 = 7;
const int pin6 = 6;
const int pin5 = 5;
const int pin4 = 4;
const unsigned long pinActiveTime = 420000;
unsigned long shutDown;

void setup() {
  Wire.begin();
  Serial.begin(9600);
  pinMode(pin8, OUTPUT);
  pinMode(pin7, OUTPUT);
  pinMode(pin6, OUTPUT);
  pinMode(pin5, OUTPUT);
  pinMode(pin4, OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT); 

  if (!rtc.begin()) {
    blinkLED(10); 
    while (1); 
  }
}

void loop() {
//rtc.adjust(DateTime(__DATE__, __TIME__));
mainRoutine();
delay(60000);
} 

void mainRoutine(){ 
  DateTime now = rtc.now();
  unsigned long delayTime;
    if (now.hour() >= dayStart && now.hour() < dayEnd) {
      activatePin(pin8);
      activatePin(pin7);
      activatePin(pin6);
      activatePin(pin5);
      activatePin(pin4);
      if (evenDAY(now.day()) == false){
        delay(14400000);
        activatePin(pin8);    
      } 
    }  
    delayTime = computeDelay(now.hour(),now.minute(),now.second()); 
    delay(delayTime);   
  } 

bool evenDAY(int day){
  return day % 2 ==0;
  }

void activatePin(int pin) {
  digitalWrite(pin, HIGH);
  delay(pinActiveTime);
  digitalWrite(pin, LOW);
}


unsigned long computeDelay(int currentHour, int currentMinutes, int currentSeconds) {
  if (currentHour >= dayStart ){
    shutDown = ((24 - currentHour + dayStart)* 3600 - currentMinutes * 60 - currentSeconds)*1000;
  }
  else{
    shutDown = ((dayStart - currentHour)* 3600 - currentMinutes * 60 - currentSeconds)*1000;  
  }
  return shutDown;
}


void blinkLED(int times) {
  for (int i = 0; i < times; i++) {
    digitalWrite(LED_BUILTIN, HIGH); 
    delay(500);                      
    digitalWrite(LED_BUILTIN, LOW);  
    delay(500);                      
  }
}

我有一个小项目，需要 Arduino 从早上 6:00 开始一次激活一个引脚，持续指定的时间。这些引脚的激活应遵循特定的逻辑，我之前已经描述过。

目前，为了灌溉我的农作物，我必须手动按下 Arduino 板上的一个小红色按钮。按下此按钮后，Arduino 成功执行上述逻辑。我正在寻找一种解决方案，可以自动执行此过程并消除人工干预的需要。

不要那样使用延迟。设置一个计时器，让 CPU 进入睡眠状态，每秒唤醒一次，计算秒数以决定执行某项操作。延迟次数有一个下限，我认为您可能超过了这个上限。这只是一个糟糕的设计，因为它让 CPU 处于忙碌等待状态，消耗能量，而使用计时器，CPU 本来可以在 99% 的时间内处于睡眠状态。

我有一个项目示例，其中每半小时运行风扇 10 分钟。这显示了如何使用 AVR（在本例中为 ATTiny85）定时器在大部分时间处于休眠状态时计算秒数。

如果您使用 RTC 定时器，您可能能够使用该定时器上的警报中断或 1s 中断线路唤醒微控制器，使用外部中断来执行操作。DS3232 可以以 1s 输出方波，可用于驱动中断。

请注意，下面的寄存器对于不同的 AVR 微控制器会略有不同。ATtiny 和 ATmega 类似但不完全相同。

/* fan_control - Copyright (c) 2016 Pat Thoyts <[email protected]>
*
* ATtiny85 with LED on pin PB2 and a 2N7000 MOSFET on PB3 which controls
* a computer fan run off 12V supply. Toggle the fan on for 10 minutes then
* off for 20 minutes. Start with the fan ON
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

/* Timing is designed for 8MHz system clock */
#ifndef F_CPU
#  define F_CPU 8000000UL
#endif

#define LED_PIN PB2
#define FAN_PIN PB3

volatile uint8_t ticks;
volatile uint8_t seconds;
volatile uint8_t minutes;

ISR(TIMER0_COMPA_vect)
{
    /* count up to 1s (254 ticks) then toggle the LED.
    * after 15 minutes, toggle the fan
    * Note: should in theory be 250 but measured it and require 254 for 1s
    * Note: 125Hz on oscilloscope is for full wave so on and off.
    */
    if (++ticks == 254)
    {
        if (++seconds == 61)
        {
            /*
            * 33% duty cycle
            * on for 10 minutes out of every 30
            */
            if (minutes == 0)   /* on */
                DDRB |= _BV(FAN_PIN);
            if (minutes == 10)  /* off */
                DDRB &= ~_BV(FAN_PIN);

            if (++minutes == 30)
                minutes = 0;
            seconds = 0;
        }
        ticks = 0;
        /* toggle the led every other second */
        if ((seconds & 1) == 0)
            PORTB |= _BV(LED_PIN);
    }
}

/* put the processor into the currently defined sleep mode */
static void
sleep_now(void)
{
    cli();
    sleep_enable();
    sei();
    sleep_cpu();
    sleep_disable();
}

/* configure timer 0 as a counter. Raises interrupts at 250 Hz */
static void
init_timer0(void)
{
    cli();
    ticks = seconds = minutes = 0;
    /*
    * WGM   = 0b010: CTC mode (0 -> OCRA)
    * COM0A = 0b00: PWM A disabled
    * COM0B = 0b00: PWM B disabled
    * CS    = 0b011: CLK/64; 0b100: CLK/256
    *    freq = 8e6 / 64 / 125 == 1000.0 ie 1kHz.
    *    freq = 8e6 / 256 / 125 == 250 Hz
    */
    TCCR0A = _BV(WGM01);
    TCCR0B = _BV(CS02);
    TCNT0 = 0;
    OCR0A = 125;
    TIMSK |= (1 << OCIE0A); /* interrupt on compare match with OCR0A */
    sei();
}

/* Configure fast PWM on PB3 (OC1B) */
static void
init_pwm_timer1()
{
    cli();
    /* set pin PB3 (OC1B) as output */
    DDRB |= _BV(DDB3);
    PORTB &= ~_BV(PB3);
    /*
    * PWM1A = 0: disabled modulator A (attached to PB0 and PB1)
    * PWM1B = 1: enable PWM mode for OCR1B and 0 when match OCR1C
    * COM1A = 0b00: OC1A disconnected
    * COM1B = 0b01: OC1B clear on compare match, set at BOTTOM,
    *               OC1B# set on compare match, clear at 0. (Table 12-1).
    * CS    = 0b0001: PCK/1
    * OCR1C = 0xFF: TOP, resets counter when matches
    *         freq = (8MHz / 1 / 256) -> 31kHz.
    */
    TCCR1 = _BV(CS10);
    GTCCR = _BV(PWM1B) | _BV(COM1B0);
    OCR1B = 60; //lower is faster 190 is stalled
    OCR1C = 255;
    sei();
}

int
main(void)
{
    wdt_enable(WDTO_1S);

    power_adc_disable();
    power_usi_disable();

    /* set all unused pins high-z, led pin output and low */
    DDRB = _BV(LED_PIN);
    PORTB = ~(_BV(LED_PIN));

    init_timer0();
    init_pwm_timer1();

    set_sleep_mode(SLEEP_MODE_IDLE);
    sei();

    for (;;)
    {
        /* sleep all the time. Gets woken up by the timer at 250Hz */
        wdt_reset();
        sleep_now();
    }
}