473,699 Members | 2,799 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

Types

Hi people
I have been working again in my tutorial, and I have finished the
"types" chapter. If you feel like "jacob bashing" this is the
occasion! I am asking for criticisms, or for things I may have said
wrong. Keep in mind that this is a tutorial, and I donot want to
overwhelm the reader with little details.

-------------------------------------------------------------------------*

Types

A machine has no concept of type, everything is just a sequence of bits,
and any operation with those sequences can be done, even if it is not
meaningful at all, for example adding two addresses, or multiplying two
character strings.

A high level programming language however, enforces the concept of types
of data. Operations are allowed between compatible types and not between
any data whatsoever. It is possible to add two integers, or an integer
and a floating point number, and even an integer and a complex number.
It is not possible to add an integer to a function or to a character
string, the operation has no meaning for those types.

An operation implies always compatible types netween the operands.
In C, all data must be associated with a specific type before it can be
used. All variables must be declared to be of a known type before any
operation with them is attempted since to be able to generate code the
compiler must know the type of each operand.

C allows the programmer to define new types based on the previously
dfined ones. This means that the type system in C is static, i.e. known
at compile time, but extensible since you can add new types.

This is in contrast to dynamic typing, where no declarations are needed
since the language associates types and data during the run time.
Dynamic typing is much more flexible, but this flexibility has a price:
the run time system must constantly check the types of the operands for
each operation to see if they are compatible, what slows down the
program considerably.

In C there is absolutely no run time checking in most operations, since
the compiler is able to check everything during the compilation, what
accelerates execution of the program, and allows the compiler to
discover a lot of errors during the compilation instead of crashing at
run time when an operation with incompatible types is attempted.
What is a type?

A first tentative, definition for what a type is, could be “a type is a
definition of an algorithm for understanding a sequence of storage
bits”. It gives the meaning of the data stored in memory. If we say that
the object a is an int, it means that the bits stored at that location
are to be understood as a natural number that is built by consecutive
additions of powers of two. If we say that the type of a is a double, it
means that the bits are to be understood as the IEEE 754 standard
sequences of bits representing a double precision floating point value.
Functions have a type too. The type of a function is determined by the
type of its return value, and all its arguments. The type of a function
is its interface with the outside world: its inputs (arguments) and its
outputs (return value).

Types in C can be incomplete, i.e. they can exist as types but nothing
is known about them, neither their size nor their bit-layout. They are
useful for encapsulating data into entities that are known only to
certain parts of the program.

Each type can have an associated pointer type: for int we have int
pointer, for double we have double pointer, etc. We can have also
pointers that point to an unspecified object. They are written as void
*, i.e. pointers to void. Some types exist only as pointers: the
function pointer type has no object counterpart since a function object
doesn’t exist in C, only pointers to functions exist.

Types classification

This type classification is based on the classification published by
Plauger and Brody, slightly modified.
Types
1. Function types
1.1 Fully qualified function types. (Functions whose full prototype is
visible)
1.2 Assumed function types (Functions whose prototype is partly or not
visible)
1.2.1 Functions whose return value is visible but not their arguments
1.2.2 Functions where the return value and their arguments are unknown.
2. Incomplete types (Types not completely specified)
2.1 void
2.2 Incomplete struct types
2.3 Incomplete array types
2.4 Incomplete union types
3. Object types
3.1 Scalar types
3.1.1 Arithmetic types
3.1.1.1 Integer types
3.1.1.1.1 Specific integer types
3.1.1.1.1.1 char (signed/unsigned)
3.1.1.1.1.2 short (signed unsigned)
3.1.1.1.1.3 int (signed/unsigned)
3.1.1.1.1.4 long (signed/unsigned)
3.1.1.1.1.5 long long (signed/unsigned)
3.1.1.1.2 Bitfields (signed/unsigned)
3.1.1.1.3 Enumeration types
3.1.1.2 Floating types
3.1.1.2.1 float
3.1.1.2.2 double
3.1.1.2.3 long double
3.1.2 Pointer types
3.1.2.1 Pointer to function
3.1.2.2 Pointer to object types
3.1.2.3 Pointer to incomplete types
3.2 Non -scalar types
3.2.1 Struct types
3.2.2 Union types
3.2.3 Array types

Integer types

The language doesn’t specify exactly how big each integer type must be,
but it has some requirements as to the minimum size of the integer
types. The char type must be at least 8 bits, the int type must be at
least 16 bits, and the long type must be at least 32 bits. How big each
integer type actually is, is defined in the standard header limits.h.

Floating types

Floating types are discussed in more detail later. Here we will just
retain that they can represent integer and non integer quantities, and
in general, their dynamic range is bigger that integers of the same
size. They have two parts: a mantissa and an exponent.
As a result, there are some values that can’t be expressed in floating
point, for instance 1/3 or 1/10. This comes as a surprise for many
people, so it is better to underscore this fact here. More explanations
for this later on.
Floating point arithmetic is approximative, and many mathematical laws
that we take for granted like a+b is equal to b+a do not apply in many
cases to floating point math.

Compatible types

There are types that share the same underlying representation. For
instance, in lcc-win32 for the Intel platform, in 32 bits, long and int
are the same. They are compatible types for that version of lcc. In the
version of lcc-linux for 64 bits however, long is 64 bits and int is 32
bits, they are no longer compatible types, but long is now compatible
with the long long type.
Plauger and Brody give the following definition for when two types are
compatible types:
Both types are the same.
Both are pointer types, with the same type qualifiers, that point to
compatible types.
Both are array types whose elements have compatible types. If both
specify repetition counts, the repetition counts are equal.
Both are function types whose return types are compatible. If both
specify types for their parameters, both declare the same number of
parameters (including ellipses) and the types of corresponding
parameters are compatible. Otherwise, at least one does not specify
types for its parameters. If the other specifies types for its
parameters, it specifies only a fixed number of parameters and does not
specify parameters of type float or of any integer types that change
when promoted.
Both are structure, union, or enumeration types that are declared in
different translation units with the same member names. Structure
members are declared in the same order. Structure and union members
whose names match are declared with compatible types. Enumeration
constants whose names match have the same values.

Incomplete types

An incomplete type is missing some part of the declaration. For instance

struct SomeType;

We know now that “SomeType” is a struct, but since the contents aren’t
specified, we can’t use directly that type. The use of this is precisely
to avoid using the type: encapsulation. Many times you want to publish
some interface but you do not want people using the structure,
allocating a structure, or doing anything else but pass those structure
to your functions. In those situations, an opaque type is a good thing
to have.

Casting

The programmer can at any time change the type associated with a piece
of data by making a “cast” operation. For instance if you have:
float f = 67.8f;
you can do
double d = (double)f;
The “(double)” means that the type of data in f should be converted into
an equvalent data using the double representation. We will come back to
types when we speak again about casts later.
Dec 10 '06
58 3451
Thad Smith wrote:
jacob navia wrote:
Floating point arithmetic is approximative, and many mathematical laws
approximate
that we take for granted like a+b is equal to b+a do not apply in many
cases to floating point math.

That is a poor example. There may be some arithmetic units for which
addition is not commutative, but I am not aware of any (excluding result
carry-over with additional precision).
Isn't that enough?
Consider "(a+b)+c is equal to
a+(b+c)".
That does not apply to integer or pointer arithmetic either.

Dec 11 '06 #11
"Harald van Dijk" <tr*****@gmail. comwrites:
Thad Smith wrote:
>jacob navia wrote:
Floating point arithmetic is approximative, and many mathematical laws
approximate
that we take for granted like a+b is equal to b+a do not apply in many
cases to floating point math.

That is a poor example. There may be some arithmetic units for which
addition is not commutative, but I am not aware of any (excluding result
carry-over with additional precision).

Isn't that enough?
>Consider "(a+b)+c is equal to
a+(b+c)".

That does not apply to integer or pointer arithmetic either.
It's different, though. Integer and pointer arithmetic are
associative *unless* an intermediate result is undefined, I think. In
floating-point arithmetic, it's possible that (a+b)+c and a+(b+c) have
different values without overflow.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
Dec 11 '06 #12
jacob navia <ja***@jacob.re mcomp.frwrote:
Types

A machine has no concept of type, everything is just a sequence of bits,
and any operation with those sequences can be done, even if it is not
meaningful at all, for example adding two addresses, or multiplying two
character strings.
Great way to start... never heard of address register, floating point
registers, and integer registers?
A high level programming language however, enforces the concept of types
of data. Operations are allowed between compatible types and not between
any data whatsoever. It is possible to add two integers, or an integer
and a floating point number, and even an integer and a complex number.
It is not possible to add an integer to a function or to a character
string, the operation has no meaning for those types.
This is a run on sentence, run on sentences are just as wrong in French
as in English so you should have known better, you are unfortunately not
the only person to make such mistakes so don't feel too bad, replace the
last comma with a full stop.
An operation implies always compatible types netween the operands.
Not necessarily. See casts. And for some operations, the compatibility
needs to run only one way.
This is in contrast to dynamic typing, where no declarations are needed
since the language associates types and data during the run time.
Dynamic typing is much more flexible, but this flexibility has a price:
the run time system must constantly check the types of the operands for
each operation to see if they are compatible, what slows down the
program considerably.
_Which_ slows down the program. And that's not the only problem; it also
leads to more run-time errors and fewer compile-time errors.

In C there is absolutely no run time checking in most operations, since
the compiler is able to check everything during the compilation, what
accelerates execution of the program,
_Which_.
What is a type?

A first tentative, definition for what a type is, could be “a type is a
A first, tentative, definition. And don't use that kind of quote mark on
Usenet - it's OK (indeed, better) if it goes into a web page.
definition of an algorithm for understanding a sequence of storage
bits”.
An unusual, but not a bad definition of type.
Each type can have an associated pointer type:
s/can have/has/.
for int we have int
pointer, for double we have double pointer, etc. We can have also
pointers that point to an unspecified object. They are written as void
*, i.e. pointers to void.
Bad line break. Break this before "void *".
Some types exist only as pointers: the function pointer type has no
object counterpart since a function object doesn’t exist in C, only
pointers to functions exist.
A function object doesn't exist (because it's a contradiction in terms),
but that doesn't mean that a function type doesn't. See 6.2.5.
Types classification

This type classification is based on the classification published by
Plauger and Brody, slightly modified.
Types
1. Function types
1.1 Fully qualified function types. (Functions whose full prototype is
visible)
1.2 Assumed function types (Functions whose prototype is partly or not
visible)
1.2.1 Functions whose return value is visible but not their arguments
1.2.2 Functions where the return value and their arguments are unknown.
You're missing variadic functions, which fall in between 1.1 and 1.2.1.
2. Incomplete types (Types not completely specified)
2.1 void
2.2 Incomplete struct types
2.3 Incomplete array types
2.4 Incomplete union types
Better keep struct and union together - not necessarily under the same
item, but not separated by array.
3. Object types
3.1 Scalar types
3.1.1 Arithmetic types
3.1.1.1 Integer types
3.1.1.1.1 Specific integer types
3.1.1.1.1.1 char (signed/unsigned)
3.1.1.1.1.2 short (signed unsigned)
3.1.1.1.1.3 int (signed/unsigned)
3.1.1.1.1.4 long (signed/unsigned)
3.1.1.1.1.5 long long (signed/unsigned)
Don't use 8-space tabs. This indentation is ridiculous.

If you mention long long, you need to mention intN_t, intmax_t, and so
forth...
3.1.1.1.2 Bitfields (signed/unsigned)
3.1.1.1.3 Enumeration types
3.1.1.2 Floating types
3.1.1.2.1 float
3.1.1.2.2 double
3.1.1.2.3 long double
....and complex types.

You also need to mention that these, including long long, are C99 only.
3.1.2 Pointer types
3.1.2.1 Pointer to function
3.1.2.2 Pointer to object types
3.1.2.3 Pointer to incomplete types
3.2 Non -scalar types
3.2.1 Struct types
3.2.2 Union types
3.2.3 Array types
This is better than 2.2-2.4 above, but at the very least be consistent.

Integer types

The language doesn’t specify exactly how big each integer type must be,
but it has some requirements as to the minimum size of the integer
types.
Wrong. It has requirements as to the minimum _values_ it can hold. This
necessarily does translate to a minimum bit size, but it pays to be
precise.
The char type must be at least 8 bits, the int type must be at
least 16 bits, and the long type must be at least 32 bits. How big each
integer type actually is, is defined in the standard header limits.h.

Floating types

Floating types are discussed in more detail later. Here we will just
retain that they can represent integer and non integer quantities, and
in general, their dynamic range is bigger that integers of the same
size.
This is highly misleading unless you define "dynamic range" and mention
that it means that a 4-byte float can't represent all values that a
4-byte int can, as much as the opposite.
They have two parts: a mantissa and an exponent.
And this is just subtly wrong. You missed one bit.
Floating point arithmetic is approximative,
Usually, but...
and many mathematical laws that we take for granted like a+b is
equal to b+a do not apply in many cases to floating point math.
....this shouldn't be true. Floating point addition _is_ commutative; it
isn't associative.
Plauger and Brody give the following definition for when two types are
compatible types:
Use the Standard instead. I _think_ what you have here is equivalent,
but check.
Incomplete types

An incomplete type is missing some part of the declaration.
No. Check the Standard: an incomplete type is an object type which does
not have the necessary information to determine its size. This does not
mean that anything need be missing; the information may simply not
exist. In particular, void is an incomplete type which cannot be
completed.
Casting

The programmer can at any time change the type associated with a piece
of data by making a “cast” operation.
s/making/using/, and see below.
For instance if you have:
float f = 67.8f;
you can do
double d = (double)f;
The “(double)” means that the type of data in f should be converted into
an equvalent data using the double representation.
Wrong, wrong, wrongity-wrong. The data in f should be left alone. The
_expression_ evaluates to the _value_ of f converted to that type. Not
the data, i.e. the bytes; purely the value.
(Oh, and: "equivalent ". Use a spill chucker.)

Do we get credit in the final document?

Richard
Dec 11 '06 #13
Keith Thompson wrote:
"Harald van Dijk" <tr*****@gmail. comwrites:
Thad Smith wrote:
jacob navia wrote:
Floating point arithmetic is approximative, and many mathematical laws
approximate
that we take for granted like a+b is equal to b+a do not apply in many
cases to floating point math.

That is a poor example. There may be some arithmetic units for which
addition is not commutative, but I am not aware of any (excluding result
carry-over with additional precision).
Isn't that enough?
Consider "(a+b)+c is equal to
a+(b+c)".
That does not apply to integer or pointer arithmetic either.

It's different, though. Integer and pointer arithmetic are
associative *unless* an intermediate result is undefined, I think.
unsigned a = UINT_MAX;
unsigned b = UINT_MAX;
unsigned long c = 1;

Now, there is no undefined behaviour in either (a + b) + c or a + (b +
c), but it's still possible for those to give different results.
In
floating-point arithmetic, it's possible that (a+b)+c and a+(b+c) have
different values without overflow.
Technically, there is no overflow in my example, but I get your point.

Dec 11 '06 #14
Chris Torek wrote:
In article <45************ **********@news .orange.fr>,
jacob navia <ja***@jacob.re mcomp.frwrote:
>>... Keep in mind that this is a tutorial, and I donot want to
overwhelm the reader with little details.


It is OK to gloss over details, but if you are going to do so, I
think you should note where this has occurred. (Maybe mark parts
with footnotes, marginal notes, some of those typographic "dingbats"
as they are called, or some other technique.)

>>-------------------------------------------------------------------------*
Types

A machine has no concept of type,


This is a huge overstatement. Not only is it not strictly true
(there are machines with "typed RAM", although they are no longer
in common use and they can make C compilers difficult or even
impossible), it is also highly misleading: a typical modern machine
still applies a type to every operation, it is just that you get
to choose the type each time you do the operation. For instance:

mulf rResult, rInput1, rInput2

could treat the two inputs as 32-bit floating-point numbers, while:

mull rResult, rInput1, rInput2

would treat the two inputs as 32-bit integer values. And of course,
on many machines including the x86, "floating-point" numbers are
handled very differently from "integer" numbers: you cannot quite
stick a full FP number into an integer register (since there are
no 80-bit integer registers), although using SSE/MMX extensions,
you can sometimes do vice versa.

A lot of machines also have "semi-typed" registers: address vs
data, for instance (see the 680x0; and even the x86 does this, to
a lesser extent: computational results commonly go in %eax,
occasionally in %edx, rarely in %esi, etc.).

On the other hand, this part is generally true:

>>everything is just a sequence of bits,
and any operation with those sequences can be done, even if it is not
meaningful at all, for example adding two addresses, or multiplying two
character strings.


I think it is worth re-phrasing this paragraph. Maybe even just make
the opening sentence something like "Machines don't enforce consistency
of types. Everything is just a sequence of bits, ..."
Yes, thanks. My intent was to say exactly that (there are no enforced
types) but I did not say it explicitely. Obviously a floating point add
assumes some structure in the bits at the input addresses, as an integer
add, etc.
>
>>A high level programming language however, enforces the concept of types
of data. Operations are allowed between compatible types and not between
any data whatsoever. It is possible to add two integers, or an integer
and a floating point number, and even an integer and a complex number.
It is not possible to add an integer to a function or to a character
string, the operation has no meaning for those types.


(This glosses over some stuff, e.g., many "high level" languages *do*
allow you to add an integer to a character string.)
Adding an integer to a character string? What would be the result of THAT?

Or maybe you mean
"9" + "1" --"91"

Dec 11 '06 #15
jacob navia wrote:
Chris Torek wrote:
>(This glosses over some stuff, e.g., many "high level" languages *do*
allow you to add an integer to a character string.)

Adding an integer to a character string? What would be the result of THAT?

Or maybe you mean
"9" + "1" --"91"
More likely "string"+1, which is legal in several languages.

--
Ian Collins.
Dec 11 '06 #16
Ian Collins wrote:
jacob navia wrote:
Chris Torek wrote:
(This glosses over some stuff, e.g., many "high level" languages *do*
allow you to add an integer to a character string.)
Adding an integer to a character string? What would be the result of THAT?

Or maybe you mean
"9" + "1" --"91"
More likely "string"+1, which is legal in several languages.
The meaning of "string"+1 is inconsistent between languages, though. In
Perl, its result is 1. In JavaScript, the result is "string1". It's
also legal C, and equivalent to "tring".

Dec 11 '06 #17
Harald van Dijk wrote:
jacob navia wrote:
>>Richard Heathfield a écrit :
>>>jacob navia said:

P.S. The difference between the classification of types as proposed by
Plauger and Brody and the classification there is that I think it is
important to differenciate function types, between functions with full
prototype

int fn(int,double);

"half prototype"

char *fn();
That isn't a half-prototype. It's a function declaration, and that's all it
is.

No, it is missing the number and types of the arguments.


Right. So it's just a function declaration that is not a prototype.
There's no such thing as a "half-prototype".

>>I do not know if this classification in function types is correct, or it
would be better to add this to the "incomplete types" section.


A function type cannot ever be an incomplete type.
Incomplete in the sense that the number and types of the function
arguments are unknown, as in an incomplete declaration the number and
types of the structure/union members are unknown.

There are two kinds:

1) Function declarations that are not prototypes, to use your terminology.
2) Completely implicit declaration where the compiler assumes:

int fn();
Dec 11 '06 #18
Harald van Dijk wrote:
Ian Collins wrote:
>>jacob navia wrote:
>>>Chris Torek wrote:

(This glosses over some stuff, e.g., many "high level" languages *do*
allow you to add an integer to a character string.)
Adding an integer to a character string? What would be the result of THAT?

Or maybe you mean
"9" + "1" --"91"

More likely "string"+1, which is legal in several languages.


The meaning of "string"+1 is inconsistent between languages, though. In
Perl, its result is 1. In JavaScript, the result is "string1". It's
also legal C, and equivalent to "tring".
But this is not adding 1 to a character string!

It means (in C) adding 1 to the ADDRESS of the start of the string,
what is completely another matter!
Dec 11 '06 #19
jacob navia said:
Harald van D?k wrote:
>jacob navia wrote:
>>>I do not know if this classification in function types is correct, or it
would be better to add this to the "incomplete types" section.


A function type cannot ever be an incomplete type.

Incomplete in the sense that the number and types of the function
arguments are unknown,
That's not what "incomplete types" means in C, though. In C, there are three
kinds of types - object types, function types, and incomplete types. If
it's a function type, it simply can't be an incomplete type. See 3.1.2.5 of
C89 or 6.2.5 of C99.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.
Dec 11 '06 #20

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

3
4538
by: John Dibling | last post by:
Could somebody please direct me to a location in the standard where POD types are defined? That is, where in the standard is it defined what attributes a POD type has that a non-POD hasn't? Also, what does the acronym stand for? Thanks, </dib> John Dibling Witty banter omitted for your protection
5
3448
by: Andy Skypeck | last post by:
I am looking for some validation against a dubious coding practice that prevails where I work. C types defined in types.h (Linux) or stdint.h (Windows, C99?) are used as if they belong to the C++ standard namespace. std::uint8_t instead of uint8_t std::uint32_t instead of uint32_t .... I don't think the use of std:: is correct. Nowhere are these types
8
2336
by: Shailesh | last post by:
One problem I've been wrestling with for a long time is how to use the C++ integral data types, vis-a-vis their size. The C++ rules guarantee that a char is at least 1 bytes, a short and int at least 2 bytes, and a long at least 4 bytes. The rules also define a size precedence to the types. In Stroustrup's book, it says that all type sizes are multiples of char, "so by definition the size of a char is 1." According to the rules, that...
188
17355
by: infobahn | last post by:
printf("%p\n", (void *)0); /* UB, or not? Please explain your answer. */
5
2097
by: Zach | last post by:
When it is being said that, "value types are created on the stack or inline as part of an object". If a value type is created in an object, and that object is being called, the value type in that object, is still created on the stack, I would say, so I don't understand this inline business. Apart from the fact that it is my understanding that "inline" as it exists in C++ doesn't exist in C#. Could someone please shed some light on this...
14
2302
by: Lane Straatman | last post by:
I would like to write a 'struct'. I have a library that is all but completely inappropriate for this task. So I'm looking for C code that fills in the gaps between: #undef whateverkeithsaysfor99compliance #define whateverkeithsays for99compliance int main(void { struct foo
159
6256
by: Bob Timpkinson | last post by:
Hi, I have a 32-bit machine... Is there anyway I can get gcc to use the following integer sizes? char: 8 bits short: 16 bits int: 32 bits long: 64 bits long long: 128 bits
3
2383
by: sophia.agnes | last post by:
Dear all, what are the major expression types in c? i have seen the following types of expressions 1) constant expressions 2) integral expressions 3) float expressions 4) pointer expressions
55
3973
by: tonytech08 | last post by:
How valuable is it that class objects behave like built-in types? I appears that the whole "constructor doesn't return a value because they are called by the compiler" thing is to enable built-in-like behavior for objects of class type. That leads to the "necessity" for the exception machinery so that errors from constructors can be handled. Is all that complexity worth it just to get built-in-like behavior from class objects? Maybe a...
0
8687
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look ! Part I. Meaning of...
0
8615
by: Hystou | last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it. First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
1
8914
by: Hystou | last post by:
Overview: Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
0
8883
tracyyun
by: tracyyun | last post by:
Dear forum friends, With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the choice of these technologies. I'm particularly interested in Zigbee because I've heard it does some...
0
7750
agi2029
by: agi2029 | last post by:
Let's talk about the concept of autonomous AI software engineers and no-code agents. These AIs are designed to manage the entire lifecycle of a software development project—planning, coding, testing, and deployment—without human intervention. Imagine an AI that can take a project description, break it down, write the code, debug it, and then launch it, all on its own.... Now, this would greatly impact the work of software developers. The idea...
1
6534
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms. Adolph will...
0
5874
by: conductexam | last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one. At the time of converting from word file to html my equations which are in the word document file was convert into image. Globals.ThisAddIn.Application.ActiveDocument.Select();...
0
4629
by: adsilva | last post by:
A Windows Forms form does not have the event Unload, like VB6. What one acts like?
1
3057
by: 6302768590 | last post by:
Hai team i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.