Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.c++ > #89160 > unrolled thread

Is this safe?

Started byMuttley@dastardlyhq.com
First post2023-02-20 16:45 +0000
Last post2023-02-21 08:15 -0800
Articles 20 on this page of 203 — 22 participants

Back to article view | Back to comp.lang.c++


Contents

  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 →


#89196

FromPaavo Helde <eesnimi@osa.pri.ee>
Date2023-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]


#89416

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2023-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]


#89165

FromTony Oliver <guinness.tony@gmail.com>
Date2023-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]


#89171

FromJames Kuyper <jameskuyper@alumni.caltech.edu>
Date2023-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]


#89172

FromÖö Tiib <ootiib@hot.ee>
Date2023-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]


#89173

FromMuttley@dastardlyhq.com
Date2023-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]


#89168

FromRichard Damon <Richard@Damon-Family.org>
Date2023-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]


#89170

FromAndrey Tarasevich <andreytarasevich@hotmail.com>
Date2023-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]


#89175

FromMuttley@dastardlyhq.com
Date2023-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]


#89182

From"Alf P. Steinbach" <alf.p.steinbach@gmail.com>
Date2023-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]


#89183

FromMuttley@dastardlyhq.com
Date2023-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]


#89193

From"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu>
Date2023-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]


#89198

FromMuttley@dastardlyhq.com
Date2023-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]


#89209

From"Alf P. Steinbach" <alf.p.steinbach@gmail.com>
Date2023-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]


#89217

FromMuttley@dastardlyhq.com
Date2023-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]


#89228

FromAndrey Tarasevich <andreytarasevich@hotmail.com>
Date2023-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]


#89213

From"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu>
Date2023-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]


#89215

FromPaavo Helde <eesnimi@osa.pri.ee>
Date2023-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]


#89220

FromMuttley@dastardlyhq.com
Date2023-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]


#89221

FromPaavo Helde <eesnimi@osa.pri.ee>
Date2023-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