Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c++ > #89160 > unrolled thread
| Started by | Muttley@dastardlyhq.com |
|---|---|
| First post | 2023-02-20 16:45 +0000 |
| Last post | 2023-02-21 08:15 -0800 |
| Articles | 20 on this page of 203 — 22 participants |
Back to article view | Back to comp.lang.c++
Is this safe? Muttley@dastardlyhq.com - 2023-02-20 16:45 +0000
Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-20 18:34 +0100
Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-20 11:16 -0800
Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-20 21:39 +0100
Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-20 12:56 -0800
Re: Is this safe? Tony Oliver <guinness.tony@gmail.com> - 2023-02-20 16:17 -0800
Re: Is this safe? Manu Raju <MR@invalid.invalid> - 2023-02-21 01:57 +0000
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:15 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 12:31 +0200
Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-21 05:36 +0100
Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-21 02:19 -0800
Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-21 14:16 +0100
Re: Is this safe? Ralf Goertz <me@myprovider.invalid> - 2023-02-21 14:40 +0100
Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-21 05:51 -0800
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 15:58 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 14:55 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 19:02 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 17:13 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 19:58 +0200
Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-02-21 12:15 -0800
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 23:41 +0200
Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-03 12:57 -0800
Re: Is this safe? Tony Oliver <guinness.tony@gmail.com> - 2023-02-20 16:14 -0800
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-20 23:48 -0500
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-21 00:05 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:14 +0000
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-20 21:18 -0500
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-20 20:38 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:18 +0000
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-21 15:12 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 14:53 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-21 10:35 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-22 09:25 +0000
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-22 22:33 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:25 +0000
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 07:05 -0800
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-22 21:21 -0800
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 09:39 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:35 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 12:30 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 10:34 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 13:20 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:00 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 18:24 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:28 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 19:01 +0200
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-23 11:57 -0500
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 19:12 +0200
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-23 11:57 -0500
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 12:20 -0500
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-02-24 02:15 +0000
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-24 15:24 -0800
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 02:14 -0500
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 07:18 -0500
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:01 +0000
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 11:50 -0500
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:41 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 19:44 +0100
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 15:02 +0100
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-02-23 14:49 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 16:25 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:10 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 20:46 +0100
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 20:05 +0000
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:48 -0800
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 22:12 -0500
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 10:49 +0200
Re: Is this safe? Ralf Fassel <ralfixx@gmx.de> - 2023-02-24 11:36 +0100
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-24 15:39 +0000
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 10:29 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 17:20 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 17:09 +0000
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-24 17:32 +0000
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 11:56 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 16:04 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 15:47 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 19:13 +0100
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-25 19:00 +0000
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 08:43 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 10:31 +0100
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-25 16:40 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 18:42 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 11:58 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 16:25 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 15:45 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 19:15 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 08:44 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 10:40 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 10:24 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 18:31 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 08:38 +0000
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-28 01:33 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 10:17 +0000
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-28 02:43 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:50 +0100
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 03:19 -0800
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 08:10 -0500
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 05:42 -0800
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 09:39 -0500
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 07:12 -0800
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 11:29 -0500
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:45 +0100
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 11:31 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 20:59 +0100
Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-01 14:29 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:37 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 15:56 +0000
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 18:34 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-01 09:37 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-01 02:29 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 19:56 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-01 12:53 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 21:13 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-02 01:48 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-03 21:44 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-03 20:16 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-04 22:55 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 07:11 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-05 20:44 +0000
Re: Is this safe? Mr Flibble <flibble2@reddwarf.jmc.corp> - 2023-03-05 21:00 +0000
Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-05 13:59 -0800
Re: Is this safe? Mr Flibble <flibble2@reddwarf.jmc.corp> - 2023-03-05 23:07 +0000
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-06 00:22 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 14:26 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-06 00:51 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-06 02:17 -0800
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-03-05 08:13 -0800
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 09:05 -0800
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-03-14 09:47 -0700
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-03-01 14:40 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:07 +0000
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-03-01 21:37 -0500
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-01 22:30 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-01 14:27 +0100
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-03-01 10:48 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-02 10:29 +0100
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 19:53 +0000
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:08 +0000
Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-02 01:32 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:56 +0000
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-02 04:02 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-02 15:00 +0100
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-02 07:59 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 15:38 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-02 11:16 -0800
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-02 11:08 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-03 09:53 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-04 06:47 -0800
Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-02 19:35 +0000
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-28 17:40 +0100
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 12:16 -0500
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 18:39 +0100
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-24 10:03 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 19:59 +0100
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-25 06:47 +0100
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-25 10:23 +0200
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 07:16 -0800
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:31 -0800
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-23 16:34 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:15 +0000
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-24 12:17 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 12:24 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 15:18 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 15:55 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 18:20 +0200
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 17:05 +0000
Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 19:24 +0200
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-24 09:46 -0800
Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 17:30 +0100
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:12 +0000
Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-23 02:47 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 15:59 +0000
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 11:55 -0500
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 08:37 -0800
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:19 -0800
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:09 +0000
Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 12:21 -0500
Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:55 +0000
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 13:57 -0800
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 17:28 -0800
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 21:44 -0800
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-24 08:48 -0800
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-21 10:58 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-22 09:26 +0000
Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-22 22:34 +0100
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:29 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 08:28 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 17:16 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 22:24 -0800
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-22 21:30 -0800
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:31 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 22:00 -0800
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 22:20 -0800
Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 01:34 -0500
Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 10:32 +0000
Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-25 00:19 -0800
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-22 08:09 -0800
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-21 22:32 -0800
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-22 08:32 -0800
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-22 09:17 -0800
Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-04-04 23:28 -0700
Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-04-05 11:08 -0700
Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-21 08:15 -0800
Page 2 of 11 — ← Prev page 1 [2] 3 4 … 11 Next page →
| From | Paavo Helde <eesnimi@osa.pri.ee> |
|---|---|
| Date | 2023-02-21 23:41 +0200 |
| Message-ID | <tt3dqc$185pf$1@dont-email.me> |
| In reply to | #89195 |
21.02.2023 22:15 Chris M. Thomasson kirjutas: > On 2/21/2023 9:58 AM, Paavo Helde wrote: >> 21.02.2023 19:13 Muttley@dastardlyhq.com kirjutas: >>> >>> Make your program multi process then. Problem solved. >> >> Too late. Nowadays I'm happy if there are less than 100 threads in the >> process, otherwise debugging them might become really tedious. >> >> >> > > 100 threads? I am wondering what they are all doing. ;^) Mostly waiting for each other, or for external events. The general goal is to have the number of active calculation threads in the order of physical CPU cores, or somewhat higher if there is hyperthreading. So the number of actively running threads is usually less than 20 or 30, the rest are waiting. I'm sure it ought be possible to reduce the number of needed threads several times by code reorganization, but the cost/benefit ratio does not seem to encourage this work.
[toc] | [prev] | [next] | [standalone]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2023-03-03 12:57 -0800 |
| Message-ID | <tttn06$nmp5$2@dont-email.me> |
| In reply to | #89196 |
On 2/21/2023 1:41 PM, Paavo Helde wrote: > 21.02.2023 22:15 Chris M. Thomasson kirjutas: >> On 2/21/2023 9:58 AM, Paavo Helde wrote: >>> 21.02.2023 19:13 Muttley@dastardlyhq.com kirjutas: >>>> >>>> Make your program multi process then. Problem solved. >>> >>> Too late. Nowadays I'm happy if there are less than 100 threads in >>> the process, otherwise debugging them might become really tedious. >>> >>> >>> >> >> 100 threads? I am wondering what they are all doing. ;^) > > Mostly waiting for each other, or for external events. Waiting for work to be pushed into a distributed work queue? I am assuming that "external events" are io, file, mouse clicks/movements/ect...? > The general goal > is to have the number of active calculation threads in the order of > physical CPU cores, or somewhat higher if there is hyperthreading. So > the number of actively running threads is usually less than 20 or 30, > the rest are waiting. Fwiw, back when I was creating some custom server software (nt4.0), I would start off with 2 threads per cpu. Then the server would go into stress testing mode, and try to self calibrate itself to the current system it is running on. This was done during the setup process. > > I'm sure it ought be possible to reduce the number of needed threads > several times by code reorganization, but the cost/benefit ratio does > not seem to encourage this work. Fair enough. :^)
[toc] | [prev] | [next] | [standalone]
| From | Tony Oliver <guinness.tony@gmail.com> |
|---|---|
| Date | 2023-02-20 16:14 -0800 |
| Message-ID | <0e89eec5-bd46-4330-824c-ad3c1eb6b7e1n@googlegroups.com> |
| In reply to | #89162 |
On Monday, 20 February 2023 at 19:16:53 UTC, Chris Vine wrote: > On Monday, 20 February 2023 at 17:33:38 UTC, Bonita Montero wrote: > > Am 20.02.2023 um 17:45 schrieb Mut...@dastardlyhq.com: > > > It occured to me that I don't actually know the answer. It works, but > > > will it always work? Could it crash certain string implementations? > > > std::string s = "hello"; > > > for(auto &c: s) c = toupper(c); > > > std::cout << s << std::endl; > > > Why should this not work ? > The problem is that UTF-8 is now more or less ubiquitous for narrow > strings and std::toupper only works for UTF-8 strings guaranteed to > be in the ASCII subset. > > Apart from the fact that in UTF-8, any one unicode code point can > require between 1 and 5 bytes (code units) to encode it, upper and > lower case representations can occupy different numbers of code > points. Since you are in Germany, one example is the esszet (ß), > which is one code point in lower case but two code points in upper > case (SS or SZ) by old/traditional orthography. The OP specifically used an ASCII string; no mention was made of UTF-8. Why did you need to bring it up?
[toc] | [prev] | [next] | [standalone]
| From | James Kuyper <jameskuyper@alumni.caltech.edu> |
|---|---|
| Date | 2023-02-20 23:48 -0500 |
| Message-ID | <tt1ifh$11hjp$1@dont-email.me> |
| In reply to | #89165 |
On 2/20/23 19:14, Tony Oliver wrote: > On Monday, 20 February 2023 at 19:16:53 UTC, Chris Vine wrote: >> On Monday, 20 February 2023 at 17:33:38 UTC, Bonita Montero wrote: >>> Am 20.02.2023 um 17:45 schrieb Mut...@dastardlyhq.com: >>>> It occured to me that I don't actually know the answer. It works, but >>>> will it always work? Could it crash certain string implementations? >>>> std::string s = "hello"; >>>> for(auto &c: s) c = toupper(c); >>>> std::cout << s << std::endl; >> >>> Why should this not work ? >> The problem is that UTF-8 is now more or less ubiquitous for narrow >> strings and std::toupper only works for UTF-8 strings guaranteed to >> be in the ASCII subset. >> >> Apart from the fact that in UTF-8, any one unicode code point can >> require between 1 and 5 bytes (code units) to encode it, upper and >> lower case representations can occupy different numbers of code >> points. Since you are in Germany, one example is the esszet (ß), >> which is one code point in lower case but two code points in upper >> case (SS or SZ) by old/traditional orthography. > > The OP specifically used an ASCII string; no mention was made of UTF-8. > > Why did you need to bring it up? I think that the answer to the original question is that it is definitely safe, because it contained only characters for which toupper() is guaranteed to work (regardless of encoding). Chris was incorrect to suggest otherwise. However, Bonita asked "why should this not work?" - in other words, how could there be any room for doubt? And the answer to that is indeed to point out that, with a different string, it might not work, so it is a legitimate question to ask if it will work with this particular string. Note that it's unnecessary to invoke UTF-8 specifically; any encoding that has MB_LEN_MAX > 1 can run into the same problem.
[toc] | [prev] | [next] | [standalone]
| From | Öö Tiib <ootiib@hot.ee> |
|---|---|
| Date | 2023-02-21 00:05 -0800 |
| Message-ID | <988f8f68-041e-49cf-bd41-3dd976226badn@googlegroups.com> |
| In reply to | #89162 |
On Monday, 20 February 2023 at 21:16:53 UTC+2, Chris Vine wrote: > > Apart from the fact that in UTF-8, any one unicode code point can > require between 1 and 5 bytes (code units) to encode it, upper and > lower case representations can occupy different numbers of code > points. From November 2003 <https://datatracker.ietf.org/doc/html/rfc3629> all 5 and 6 byte sequences were removed and so UTF-8 code point is now up to 4 bytes. But as a "character" can be made of several code points there are seemingly no limits. Flag of Scotland (🏴) takes 28 bytes.
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-21 09:14 +0000 |
| Message-ID | <tt221h$13f1e$1@dont-email.me> |
| In reply to | #89161 |
On Mon, 20 Feb 2023 18:34:34 +0100 Bonita Montero <Bonita.Montero@gmail.com> wrote: >Am 20.02.2023 um 17:45 schrieb Muttley@dastardlyhq.com: > >> It occured to me that I don't actually know the answer. It works, but >> will it always work? Could it crash certain string implementations? >> std::string s = "hello"; >> for(auto &c: s) c = toupper(c); >> std::cout << s << std::endl; > >Why should this not work ? Because I don't know where the reference is pointing to. Its been standard with strings not to alter the contents returned by c_str() so is this a similar case or is it an analogue of just doing s[<index>] which is gauranteed safe?
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2023-02-20 21:18 -0500 |
| Message-ID | <eSVIL.197821$5S78.49415@fx48.iad> |
| In reply to | #89160 |
On 2/20/23 11:45 AM, Muttley@dastardlyhq.com wrote: > It occured to me that I don't actually know the answer. It works, but will > it always work? Could it crash certain string implementations? > > std::string s = "hello"; > for(auto &c: s) c = toupper(c); > std::cout << s << std::endl; > One possible issue is the type of c will be char& but if char is signed, then if the string contains any characters with the sign bit set, toupper will have undefined behavior. you need to cast the value c to unsigned char before passing to toupper (which will then convert it to int). This is a case where auto gives you problems, as if you intend to be able to handle other versions of string built on types other than char, you need to know the unsigned equivalent for them. The localized toupper can handle that sort of operation (as it doesn't handle the -1 case, so it takes a charT parameter, not an int). As others have mentioned, it also assumes that your string is using a single byte encoding for characters (like plain ASCII, or the old "code-page" style text strings), as multi-byte encoding can't be handled by this form of toupper().
[toc] | [prev] | [next] | [standalone]
| From | Andrey Tarasevich <andreytarasevich@hotmail.com> |
|---|---|
| Date | 2023-02-20 20:38 -0800 |
| Message-ID | <tt1hs1$11hjh$1@dont-email.me> |
| In reply to | #89160 |
On 02/20/23 8:45 AM, Muttley@dastardlyhq.com wrote: > It occured to me that I don't actually know the answer. It works, but will > it always work? Could it crash certain string implementations? > > std::string s = "hello"; > for(auto &c: s) c = toupper(c); > std::cout << s << std::endl; No, it is not safe in general case. Functions from <cctype> group generally require either a non-negative arguments or `EOF`. Otherwise, the behavior is undefined. This means that when you pass `char` values to these functions you better be sure that your `char` is unsigned or, at least, that all `char` values you are passing are non-negative. If you are not sure of that, you'll be better off explicitly casting the argument to `unsigned char`: for(auto &c: s) c = toupper((unsigned char) c); -- Best regards, Andrey
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-21 09:18 +0000 |
| Message-ID | <tt228c$13ftg$1@dont-email.me> |
| In reply to | #89170 |
On Mon, 20 Feb 2023 20:38:24 -0800 Andrey Tarasevich <andreytarasevich@hotmail.com> wrote: >On 02/20/23 8:45 AM, Muttley@dastardlyhq.com wrote: >> It occured to me that I don't actually know the answer. It works, but will >> it always work? Could it crash certain string implementations? >> >> std::string s = "hello"; >> for(auto &c: s) c = toupper(c); >> std::cout << s << std::endl; > >No, it is not safe in general case. Functions from <cctype> group >generally require either a non-negative arguments or `EOF`. Otherwise, >the behavior is undefined. > >This means that when you pass `char` values to these functions you >better be sure that your `char` is unsigned or, at least, that all >`char` values you are passing are non-negative. > >If you are not sure of that, you'll be better off explicitly casting the >argument to `unsigned char`: > > for(auto &c: s) c = toupper((unsigned char) c); I can't believe I needed to explain what I meant by safe. I was not talking about character encoding FFS, I simply used toupper as an example. Ok, is this safe: for(auto &c: s) c = 'x'; Or will it screw up the string object or have no effect in some cases just as altering the contents returned by the c_str() pointer can sometimes have?
[toc] | [prev] | [next] | [standalone]
| From | "Alf P. Steinbach" <alf.p.steinbach@gmail.com> |
|---|---|
| Date | 2023-02-21 15:12 +0100 |
| Message-ID | <tt2jgo$15erm$1@dont-email.me> |
| In reply to | #89175 |
On 2023-02-21 10:18 AM, Muttley@dastardlyhq.com wrote: > On Mon, 20 Feb 2023 20:38:24 -0800 > Andrey Tarasevich <andreytarasevich@hotmail.com> wrote: >> On 02/20/23 8:45 AM, Muttley@dastardlyhq.com wrote: >>> It occured to me that I don't actually know the answer. It works, but will >>> it always work? Could it crash certain string implementations? >>> >>> std::string s = "hello"; >>> for(auto &c: s) c = toupper(c); >>> std::cout << s << std::endl; >> >> No, it is not safe in general case. Functions from <cctype> group >> generally require either a non-negative arguments or `EOF`. Otherwise, >> the behavior is undefined. >> >> This means that when you pass `char` values to these functions you >> better be sure that your `char` is unsigned or, at least, that all >> `char` values you are passing are non-negative. >> >> If you are not sure of that, you'll be better off explicitly casting the >> argument to `unsigned char`: >> >> for(auto &c: s) c = toupper((unsigned char) c); > > I can't believe I needed to explain what I meant by safe. I was not talking > about character encoding FFS, I simply used toupper as an example. > > Ok, is this safe: > > for(auto &c: s) c = 'x'; > > Or will it screw up the string object or have no effect in some cases just > as altering the contents returned by the c_str() pointer can sometimes have? Demonstrates the need for making examples short and to the point, to not introduce extraneous issues. The assignment is safe. `c` is a reference to an item in the string, within the string bounds, i.e. it can't be a reference to the null-item that since C++11 is effectively required past the end of the string. Not what you're asking, but the common convention in C++ is to separate the type specification from the variable, i.e. `auto& c` not `auto &c`. But on the third and gripping hand, in this case I'd write `char& c`, since there's no advantage in `auto` here and it obscures things. - Alf
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-21 14:53 +0000 |
| Message-ID | <tt2lsl$15ohe$1@dont-email.me> |
| In reply to | #89182 |
On Tue, 21 Feb 2023 15:12:39 +0100 "Alf P. Steinbach" <alf.p.steinbach@gmail.com> wrote: >On 2023-02-21 10:18 AM, Muttley@dastardlyhq.com wrote: >> Ok, is this safe: >> >> for(auto &c: s) c = 'x'; >> >> Or will it screw up the string object or have no effect in some cases just >> as altering the contents returned by the c_str() pointer can sometimes have? > >Demonstrates the need for making examples short and to the point, to not >introduce extraneous issues. 3 lines is short and I didn't introduce any extranious issues. Other posters created them. >`c` is a reference to an item in the string, within the string bounds, >i.e. it can't be a reference to the null-item that since C++11 is >effectively required past the end of the string. Ok. However in the past with some implementations of std::string, modifying the contents of the buffer returned by c_str() can have undefined consequences. I simply wondered if this was a similar situation. >Not what you're asking, but the common convention in C++ is to separate >the type specification from the variable, i.e. `auto& c` not `auto &c`. Whose common convention? >But on the third and gripping hand, in this case I'd write `char& c`, >since there's no advantage in `auto` here and it obscures things. Thats ironic coming from you. :)
[toc] | [prev] | [next] | [standalone]
| From | "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> |
|---|---|
| Date | 2023-02-21 10:35 -0800 |
| Message-ID | <e84b5538-049b-44fc-be30-2a7625f49503n@googlegroups.com> |
| In reply to | #89183 |
On Tuesday, February 21, 2023 at 9:53:23 AM UTC-5, Mut...@dastardlyhq.com wrote: > On Tue, 21 Feb 2023 15:12:39 +0100 > "Alf P. Steinbach" <alf.p.s...@gmail.com> wrote: > >On 2023-02-21 10:18 AM, Mut...@dastardlyhq.com wrote: > >> Ok, is this safe: > >> > >> for(auto &c: s) c = 'x'; > >> > >> Or will it screw up the string object or have no effect in some cases just > >> as altering the contents returned by the c_str() pointer can sometimes have? > > > >Demonstrates the need for making examples short and to the point, to not > >introduce extraneous issues. > 3 lines is short and I didn't introduce any extranious issues. Other posters > created them. No, they didn't. When there's multiple possible reasons why you might be worried about whether a given piece of code is safe, you need to identify which of the possibilities is the one you are actually worried about. You considered it so obvious that you don't care about UTF-8, that you didn't consider the possibility that other people would consider that to be the most obvious safety concern. The people who responded considered the resolution of the issue that you were concerned with to be so obvious that they didn't even consider the possibility that you were uncertain about it.
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-22 09:25 +0000 |
| Message-ID | <tt4n2n$1fp0v$1@dont-email.me> |
| In reply to | #89193 |
On Tue, 21 Feb 2023 10:35:34 -0800 (PST) "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> wrote: >On Tuesday, February 21, 2023 at 9:53:23 AM UTC-5, Mut...@dastardlyhq.com >wrote: >> On Tue, 21 Feb 2023 15:12:39 +0100 >> "Alf P. Steinbach" <alf.p.s...@gmail.com> wrote: >> >On 2023-02-21 10:18 AM, Mut...@dastardlyhq.com wrote: >> >> Ok, is this safe: >> >> >> >> for(auto &c: s) c = 'x'; >> >> >> >> Or will it screw up the string object or have no effect in some cases >just >> >> as altering the contents returned by the c_str() pointer can sometimes >have? >> > >> >Demonstrates the need for making examples short and to the point, to not >> >introduce extraneous issues. >> 3 lines is short and I didn't introduce any extranious issues. Other posters > >> created them. > >No, they didn't. When there's multiple possible reasons why you might be >worried >about whether a given piece of code is safe, you need to identify which of the >possibilities is the one you are actually worried about. You considered it so >obvious that you don't care about UTF-8, that you didn't consider the >possibility >that other people would consider that to be the most obvious safety concern. Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety means will the program crash or have hidden bugs, not whether a string gets translated into uppercase properly or not which would be immediately obvious. >The people who responded considered the resolution of the issue that you were >concerned with to be so obvious that they didn't even consider the possibility >that you were uncertain about it. Don't worry, next time I'll ask in crayon.
[toc] | [prev] | [next] | [standalone]
| From | "Alf P. Steinbach" <alf.p.steinbach@gmail.com> |
|---|---|
| Date | 2023-02-22 22:33 +0100 |
| Message-ID | <tt61ml$1karm$1@dont-email.me> |
| In reply to | #89198 |
On 2023-02-22 10:25 AM, Muttley@dastardlyhq.com wrote: > On Tue, 21 Feb 2023 10:35:34 -0800 (PST) > "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> wrote: >> On Tuesday, February 21, 2023 at 9:53:23 AM UTC-5, Mut...@dastardlyhq.com >> wrote: >>> On Tue, 21 Feb 2023 15:12:39 +0100 >>> "Alf P. Steinbach" <alf.p.s...@gmail.com> wrote: >>>> On 2023-02-21 10:18 AM, Mut...@dastardlyhq.com wrote: >>>>> Ok, is this safe: >>>>> >>>>> for(auto &c: s) c = 'x'; >>>>> >>>>> Or will it screw up the string object or have no effect in some cases >> just >>>>> as altering the contents returned by the c_str() pointer can sometimes >> have? >>>> >>>> Demonstrates the need for making examples short and to the point, to not >>>> introduce extraneous issues. >>> 3 lines is short and I didn't introduce any extranious issues. Other posters >> >>> created them. >> >> No, they didn't. When there's multiple possible reasons why you might be >> worried >> about whether a given piece of code is safe, you need to identify which of the >> possibilities is the one you are actually worried about. You considered it so >> obvious that you don't care about UTF-8, that you didn't consider the >> possibility >> that other people would consider that to be the most obvious safety concern. > > Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety > means will the program crash or have hidden bugs, not whether a string gets > translated into uppercase properly or not which would be immediately obvious. The UB includes that the program can crash. >> The people who responded considered the resolution of the issue that you were >> concerned with to be so obvious that they didn't even consider the possibility >> that you were uncertain about it. > > Don't worry, next time I'll ask in crayon. The sarcasm is well anchored in ignorance. - Alf
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-23 09:25 +0000 |
| Message-ID | <tt7bdo$1r5bk$1@dont-email.me> |
| In reply to | #89209 |
On Wed, 22 Feb 2023 22:33:09 +0100 "Alf P. Steinbach" <alf.p.steinbach@gmail.com> wrote: >On 2023-02-22 10:25 AM, Muttley@dastardlyhq.com wrote: >> On Tue, 21 Feb 2023 10:35:34 -0800 (PST) >> "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> wrote: >>> On Tuesday, February 21, 2023 at 9:53:23 AM UTC-5, Mut...@dastardlyhq.com >>> wrote: >>>> On Tue, 21 Feb 2023 15:12:39 +0100 >>>> "Alf P. Steinbach" <alf.p.s...@gmail.com> wrote: >>>>> On 2023-02-21 10:18 AM, Mut...@dastardlyhq.com wrote: >>>>>> Ok, is this safe: >>>>>> >>>>>> for(auto &c: s) c = 'x'; >>>>>> >>>>>> Or will it screw up the string object or have no effect in some cases >>> just >>>>>> as altering the contents returned by the c_str() pointer can sometimes >>> have? >>>>> >>>>> Demonstrates the need for making examples short and to the point, to not >>>>> introduce extraneous issues. >>>> 3 lines is short and I didn't introduce any extranious issues. Other >posters >>> >>>> created them. >>> >>> No, they didn't. When there's multiple possible reasons why you might be >>> worried >>> about whether a given piece of code is safe, you need to identify which of >the >>> possibilities is the one you are actually worried about. You considered it >so >>> obvious that you don't care about UTF-8, that you didn't consider the >>> possibility >>> that other people would consider that to be the most obvious safety concern. > >> >> Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety >> means will the program crash or have hidden bugs, not whether a string gets >> translated into uppercase properly or not which would be immediately obvious. > > >The UB includes that the program can crash. Feel free to explain how toupper could crash.
[toc] | [prev] | [next] | [standalone]
| From | Andrey Tarasevich <andreytarasevich@hotmail.com> |
|---|---|
| Date | 2023-02-23 07:05 -0800 |
| Message-ID | <tt7vbe$1t5b1$1@dont-email.me> |
| In reply to | #89217 |
On 02/23/23 1:25 AM, Muttley@dastardlyhq.com wrote: > > Feel free to explain how toupper could crash. > There's no such concept as "explaining" undefined behavior. Yet, it could be very simple. The implementation treats `toupper` as an intrinsic, and the compiler explicitly generates a "CRASH NOW!!11" instruction for invalid arguments. Let's say that in their implementation of `toupper` it would result in a negligible performance penalty or no penalty at all. GCC is well-known to do such things, for one example. -- Best regards, Andrey
[toc] | [prev] | [next] | [standalone]
| From | "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> |
|---|---|
| Date | 2023-02-22 21:21 -0800 |
| Message-ID | <8c098d25-eafe-4ced-b472-a7964127cda8n@googlegroups.com> |
| In reply to | #89198 |
On Wednesday, February 22, 2023 at 4:25:59 AM UTC-5, Mut...@dastardlyhq.com wrote: > On Tue, 21 Feb 2023 10:35:34 -0800 (PST) > "james...@alumni.caltech.edu" <james...@alumni.caltech.edu> wrote: > >On Tuesday, February 21, 2023 at 9:53:23 AM UTC-5, Mut...@dastardlyhq.com > >wrote: ... > >> 3 lines is short and I didn't introduce any extranious issues. Other posters > > > >> created them. > > > >No, they didn't. When there's multiple possible reasons why you might be > >worried > >about whether a given piece of code is safe, you need to identify which of the > >possibilities is the one you are actually worried about. You considered it so > >obvious that you don't care about UTF-8, that you didn't consider the > >possibility > >that other people would consider that to be the most obvious safety concern. > Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety > means will the program crash or have hidden bugs, not whether a string gets > translated into uppercase properly or not which would be immediately obvious. Not getting the expected results can make other parts of the program malfunction. There are certainly more dangerous problems a program can have, but there's more reasons to worry about that issue than about the one that was your actual concern.
[toc] | [prev] | [next] | [standalone]
| From | Paavo Helde <eesnimi@osa.pri.ee> |
|---|---|
| Date | 2023-02-23 09:39 +0200 |
| Message-ID | <tt756o$1qfle$1@dont-email.me> |
| In reply to | #89198 |
22.02.2023 11:25 Muttley@dastardlyhq.com kirjutas: > Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety > means will the program crash or have hidden bugs, not whether a string gets > translated into uppercase properly or not which would be immediately obvious. Because you asked: I have seen isdigit() crashing hard on negative values, would not be surprised if toupper() would behave the same in some implementation. In case of a multi-byte UTF-8 character encoded in a std::string all its bytes would have a negative value if 'char' is signed on that platform. So there.
[toc] | [prev] | [next] | [standalone]
| From | Muttley@dastardlyhq.com |
|---|---|
| Date | 2023-02-23 09:35 +0000 |
| Message-ID | <tt7c1d$1r754$1@dont-email.me> |
| In reply to | #89215 |
On Thu, 23 Feb 2023 09:39:04 +0200 Paavo Helde <eesnimi@osa.pri.ee> wrote: >22.02.2023 11:25 Muttley@dastardlyhq.com kirjutas: > >> Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety >> means will the program crash or have hidden bugs, not whether a string gets >> translated into uppercase properly or not which would be immediately obvious. > > > >Because you asked: I have seen isdigit() crashing hard on negative Thats clearly a library bug. All bets are off when they exist. >In case of a multi-byte UTF-8 character encoded in a std::string all its >bytes would have a negative value if 'char' is signed on that platform. >So there. One would assume unsigned would be used internally.
[toc] | [prev] | [next] | [standalone]
| From | Paavo Helde <eesnimi@osa.pri.ee> |
|---|---|
| Date | 2023-02-23 12:30 +0200 |
| Message-ID | <tt7f8f$1rh5j$1@dont-email.me> |
| In reply to | #89220 |
23.02.2023 11:35 Muttley@dastardlyhq.com kirjutas: > On Thu, 23 Feb 2023 09:39:04 +0200 > Paavo Helde <eesnimi@osa.pri.ee> wrote: >> 22.02.2023 11:25 Muttley@dastardlyhq.com kirjutas: >> >>> Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety >>> means will the program crash or have hidden bugs, not whether a string gets >>> translated into uppercase properly or not which would be immediately obvious. >> >> >> >> Because you asked: I have seen isdigit() crashing hard on negative > > Thats clearly a library bug. All bets are off when they exist. What makes you think so? The C standard clearly says in 7.4 (Character handling <ctype.h>): "In all cases the argument is an int, the value of which shall be representable as an unsigned char or shall equal the value of the macro EOF. If the argument has any other value, the behavior is undefined." Undefined behavior may or may not involve a program crash. > >> In case of a multi-byte UTF-8 character encoded in a std::string all its >> bytes would have a negative value if 'char' is signed on that platform. >> So there. > > One would assume unsigned would be used internally. Alas, std::string is standardized to use plain char, whose signedness is implementation dependent.
[toc] | [prev] | [next] | [standalone]
Page 2 of 11 — ← Prev page 1 [2] 3 4 … 11 Next page →
Back to top | Article view | comp.lang.c++
csiph-web