#define ?

[4kTRB]

Varför deklareras inte RREF och RNOMINAL som konstanter?

Kod: Markera allt

#include <Arduino.h>
#include <Adafruit_MAX31865.h>

/***************************************************
  This is a library for the Adafruit PT100/P1000 RTD Sensor w/MAX31865

  Designed specifically to work with the Adafruit RTD Sensor
  ----> https://www.adafruit.com/products/3328

  This sensor uses SPI to communicate, 4 pins are required to
  interface
  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.
  BSD license, all text above must be included in any redistribution
 ****************************************************/
// Use software SPI: CS, DI, DO, CLK
Adafruit_MAX31865 max = Adafruit_MAX31865(10, 11, 12, 13);
// use hardware SPI, just pass in the CS pin
//Adafruit_MAX31865 max = Adafruit_MAX31865(10);

// The value of the Rref resistor. Use 430.0 for PT100 and 4300.0 for PT1000
#define RREF      430.0
// The 'nominal' 0-degrees-C resistance of the sensor
// 100.0 for PT100, 1000.0 for PT1000
#define RNOMINAL  100.0

[sodjan]

Hur vet du (eller varför tror du) att de inte gör det?

[Icecap]

Kanske:
#define RNOMINAL (float)100.0

[4kTRB]

Eller varför inte
const float RREF = 430.0;
?

[Icecap]

Det kan vara dumt att ändra definitionstypen då källkoden kan vara gjort på ett specifikt sätt som ger problem med konstanter.

Men det rätta är ju att göra det.

[TomasL]

Av den enkla anledningen att han som skrivit programmet är rätt okunnig.

De är definierade som ett slags konstanter, dock genom att deklarera dem i preprocessorn med #define, får man ingen som helst felkontroll av dem.
Mycket bättre att använda riktiga konstanter i stället, eftersom kompilatorn kan varna för typfel och liknande.

[Icecap]

Håller helt med - men dessa lib'bar är väl sällan helt 100% korrekta.

Nu kan det ju faktisk vara så att definitionen sparas i en const senare i programmet.

[Mr Andersson]

constexpr är nästan alltid bättre än const för litterära värden.

Med const får kompilatorn själv välja om värden ska räknas ut vid kompilering eller vid körning.
Med constexpr måste det ske vid kompilering, och du får kompileringsfel om det inte går.

Av den lilla koden som visas gör det ingen direkt skillnad, men det beror också på hur värdena används senare.
Men det skadar inte att lära sig använda constexpr.

[Icecap]

Och för att använda constexpr ska programmeringsspråket vara C++11 eller nyarer.

[hummel]

Av den enkla anledningen att han som skrivit programmet är rätt okunnig.

De är definierade som ett slags konstanter, dock genom att deklarera dem i preprocessorn med #define, får man ingen som helst felkontroll av dem.
Mycket bättre att använda riktiga konstanter i stället, eftersom kompilatorn kan varna för typfel och liknande.

I just det här fallet är det en hon.

[arvidb]

Av den enkla anledningen att han som skrivit programmet är rätt okunnig.

De är definierade som ett slags konstanter, dock genom att deklarera dem i preprocessorn med #define, får man ingen som helst felkontroll av dem.
Mycket bättre att använda riktiga konstanter i stället, eftersom kompilatorn kan varna för typfel och liknande.

Det där får du nog förklara närmare. Varför skulle man inte få felkontroll med #define? Kompilatorn kommer ju fortfarande att klaga efter att preprocessorn har gjort sitt, om något är fel med typen.

Eller varför inte
const float RREF = 430.0;
?

Motsvarigheten du söker är

Kod: Markera allt

static const float RREF = 430.0;

(Glöm inte static!) Med optimering påslagen skulle detta ofta generera exakt samma kod som en #define.

Om du skippar static så blir det annorlunda: variabeln skulle då bli global och allokeras i textsegmentet. Och kunna refereras från hela det länkade programmet.

Om du deklarerar variabeln som en const (med eller utan static) så går det att göra &RREF, vilket inte går med #define. Vilket verkar vara en ganska konstig sak att göra, så på det sättet ger en #define lite bättre felkoll, IMO.

Om du deklarerar en större konstant, till exempel en textsträng eller en struct, så kan jag tänka mig att det vore bättre att använda static const eftersom datat då garanterat bara lagras en gång och kan refereras av kompilatorn med en pekare. Med en define så kommer kanske datat att lagras på varje plats det används, om inte kompilatorn är smart.

Det "rätta" svaret här är nästan säkert att använda det som du tycker gör koden mer lättläst!

[mAVRick]

RREF och RNOMINAL ser ju ut som att de beror på vilken typ av sensor som används.
Då skulle man kunna tänka sig att man kan vilja skicka in dessa paramuttrar vid bygget istället för att ändra dem direkt i koden. Inte minst om man vill bygga flera binärer för olika sensorer t.ex.

[4kTRB]

Så det vore inte bra att deklarera
#define RREF 430.0
#define RNOMINAL 100.0
i filen Adafruit_MAX31865.h ?

Fast det är väl inga deklarationer utan definitioner och skulle
i så fall vara i filen Adafruit_MAX31865.cpp ?