Difference between revisions of "Talk:Main Page/suggestions"

Revision as of 18:47, 3 November 2023

This page collects edit suggestions from new and logged-out users when editing is temporarily disabled due to vandalism. Click the "+" at the top to leave a message. Please make sure to include a link to the page you are referencing. See /archive and /archive 1 for old suggestions that have been responded to.

new expression missing exception specs

Somewhere way down in that wall of text there is a mention of std::bad_array_new_length, but that's it. I think there should be a dedicated section "Exceptions" (as in other docs on this site) documenting std::bad_alloc and std::bad_array_new_length as well as the non-throwing versions, as this is pretty fundamental. Perhaps also an example.

Thanks! 213.68.42.195 03:02, 25 February 2019 (PST)

New user

Hello, I would like to make changes to the C++ compiler support page related to the addition of the "Modules" and "Coroutines" features to C++20. Can somebody give me permissions to edit or otherwise do the changes as per the following articles:

https://www.phoronix.com/scan.php?page=news_item&px=Coroutines-Modules-CPP20 https://herbsutter.com/2019/02/23/trip-report-winter-iso-c-standards-meeting-kona/

--Trifud (talk) 23:15, 26 February 2019 (PST)

How long time does it take for a user to be activated? --Trifud (talk) 23:09, 28 February 2019 (PST)

RFC: another implementation of Gadget-StandardRevision

(function() {
'use strict';
var styles = document.createElement('style');
styles.textContent = '[hidden] { display: none !important; }';
styles.textContent += '.stdrev-rev-hide > tbody > tr > td { border: none !important; padding: 0 !important; }'
styles.textContent += '.stdrev-rev-hide > tbody > tr > td:nth-child(2) { display: none; }'
styles.textContent += '.stdrev-rev-hide { border: none; }'
styles.textContent += '.stdrev-rev-hide > span > .t-mark-rev { display: none; }'
document.head.append(styles);
 
var rev = mw.config.get('wgTitle').indexOf('c/') === 0 ?
	[ 'C89', 'C99', 'C11' ] :
	[ 'C++98', 'C++03', 'C++11', 'C++14', 'C++17', 'C++20' ];
 
var select = $('<div class="vectorMenu"></div>').appendTo('#cpp-head-tools-right');
select.append('<h5><span>Std rev</span></h5>');
var list = $('<ul>').appendTo($('<div class="menu">').appendTo(select));
$.each(['DIFF'].concat(rev), function(i, v) {
	list.append('<li><a href="#'+v+'">'+v+'</a></li>');
});
list.on('click', 'a', function(e) {
	list.find('a').css('font-weight', 'normal');
	$(this).css('font-weight', 'bold');
	curr_rev = e.target.innerText;
	on_rev_changed();
});
 
var curr_rev = 'DIFF';
 
// Returns true if an element should be shown in the current revision, that is, either curr_rev is
// DIFF (i.e. show all), or curr_rev is within the range [since, until). The range [since, until)
// is inspected from the classes of `el`.
// `el` may be the same element as the one to be shown if it has the needed classes, or it may be a
// revision marker or a collection thereof (e.g. one expanded from {{mark since foo}}, or from the
// {{mark since foo}}{{mark until bar}} combo).
// `el` may be either a HTML element or a jQuery object.
// Note that this correctly handle the case when `el` represents an empty set of elements (in which
// case the element is always shown).
function should_be_shown(el) {
	if (curr_rev === 'DIFF') return true;
	var curr_revid = rev.indexOf(curr_rev);
	var since = 0, until = rev.length;
	$.each(rev, function(i) {
		var ssince = 't-since-'+rev[i].toLowerCase().replace(/\+/g, 'x');
		var suntil = 't-until-'+rev[i].toLowerCase().replace(/\+/g, 'x');
		if ($(el).hasClass(ssince)) since = i;
		if ($(el).hasClass(suntil)) until = i;
	});
	return since <= curr_revid && curr_revid < until;
}
 
// Called when user changes the selected revision. Inside this function, curr_rev is already set to
// the value after the change.
function on_rev_changed() {
	handle_dcl();
	renumber_dcl();
	handle_dsc();
	handle_nv();
	handle_rev();
	handle_headings();
	handle_list_items();
	$('.t-rev-begin, .t-rev-inl').toggleClass('stdrev-rev-hide', curr_rev !== 'DIFF');
	$('.t-mark-rev').each(function() {
		this.hidden = curr_rev !== 'DIFF';
		if ($(this.nextSibling).is('br'))
			this.nextSibling.hidden = curr_rev !== 'DIFF';
	});
}
 
// Returns true if the jQuery object `el` contains at least one element, and all contained elements
// are hidden; otherwise returns false.
// This is used to hide a 'parent' or 'heading' element when all its contents are hidden.
function all_hidden(el) { return $(el).length > 0 && !$(el).is(':not([hidden])'); }
 
// Hide or show the elements expanded from the {{dcl ...}} template family. See documentation at
// https://en.cppreference.com/w/Template:dcl/doc .
// The dcl items (expanded from {{dcl | ... }}) may either appear alone or as children of versioned
// declaration list (expanded from {{dcl rev begin | ... }}). In the latter case, the revision may
// be supplied by the dcl items or by the dcl-rev (in the latter case the dcl-rev has class
// t-dcl-rev-notes).
// For the use of renumber_dcl(), each dcl-rev is marked as hidden if all its children dcl items
// are hidden, and vice versa.
function handle_dcl() {
	$('.t-dcl').each(function() {
		this.hidden = !should_be_shown(this);
	});
	$('.t-dcl-rev').each(function() {
		if ($(this).is('.t-dcl-rev-notes')) {
			var hidden = !should_be_shown(this);
			this.hidden = hidden;
			$(this).find('.t-dcl').each(function() {
				this.hidden = hidden;
			});
		} else {
			this.hidden = all_hidden($(this).find('.t-dcl'));
		}
	});
	$('.t-dcl-begin .t-dsc-header').each(function() {
		var marker = $(this).find('> td > div > .t-mark-rev');
		var lastheader = $(this).nextUntil(':not(.t-dsc-header)').addBack();
		var elts = lastheader.nextUntil('.t-dsc-header').filter('.t-dcl, .t-dcl-rev');
		this.hidden = all_hidden(elts) || !should_be_shown(marker);
	});
	$('.t-dcl-h').each(function() {
		this.hidden = all_hidden($(this).nextUntil(':not(.t-dcl, .t-dcl-rev)'));
	});
}
 
// Ensure that each visible dcl item in a dcl list is contiguously numbered, and rewrite mentions
// to these numbers to use the modified numbering.
// If a list item (e.g. those expanded from @m@) contains no number after the rewrite (i.e. it's
// inapplicable in current revision), it is hidden.
// Note that the use of '~ * .t-li, ~ * .t-v' effectively establishes a kind of scoping: only
// numbers that appear after the dcl list and are more nested in the DOM hierarchy are affected
// by the renumbering.
// Requires that handle_dcl() has been called.
function renumber_dcl() {
	$('.t-dcl-begin').each(function() {
		var numbering_map = [];
		var i = 0;
		$(this).find('.t-dcl, .t-dcl-rev').each(function() {
			var num_cell;
			if ($(this).is('.t-dcl'))
				num_cell = $(this).children('td:nth-child(2)');
			else
				num_cell = $(this).find('> tr.t-dcl-rev-aux > td:nth-child(2)');
			var number_text = /\s*\((\d+)\)\s*/.exec(num_cell.text());
			if (!num_cell.attr('data-orig-num') && number_text)
				num_cell.attr('data-orig-num', number_text[1]);
			var original_num = num_cell.attr('data-orig-num');
			if (original_num) {
				if (! numbering_map[original_num])
					numbering_map[original_num] = $(this).is('[hidden]') ? null : ++i;
				num_cell.text('('+numbering_map[original_num]+')');
			}
		});
		$(this).find('~ * .t-li, ~ * .t-v').each(function() {
			if (! $(this).attr('data-orig-v'))
				$(this).attr('data-orig-v', $(this).text().replace(/[()]/g, ''));
			var original_numbers = [];
			$.each($(this).attr('data-orig-v').split(','), function(i, v) {
				var match = /(\d+)(?:-(\d+))?/.exec(v);
				if (match[2])
					for (var i = +match[1]; +i <= +match[2]; ++i)
						original_numbers.push(i);
				else
					original_numbers.push(match[1]);
			});
			var numbers = $.map(original_numbers, function(x) {
				return numbering_map[x];
			});
			var s = [];
			for (var i = 0; i < numbers.length; ++i) {
				if (numbers[i+1] - numbers[i] === 1 && numbers[i+2] - numbers[i+1] === 1) {
					var begin = numbers[i];
					while (numbers[i+1] - numbers[i] === 1)
						++i;
					s.push(begin+'-'+numbers[i]);
				} else {
					s.push(numbers[i]);
				}
			}
			if ($(this).is('.t-li')) {
				this.parentElement.hidden = numbers.length === 0;
				$(this).text(s.join(',')+')');
			} else
				$(this).text('('+s.join(',')+')');
		});
	});
}
// Hide or show the elements expanded from the {{dsc ...}} template family. See documentation at
// https://en.cppreference.com/w/Template:dcl/doc .
// The revision markers are in the first cell of each dsc item. In the general case, the visibility
// of a dsc item is control by a single revision marker. But if a specialized template is used,
// and the amount of entity names in the first cell matches the lines of the revision markers,
// then each line controls the visibility of a single entity name, and the dsc item is hidden only
// if all the entity names are hidden.
// If all the dsc items are hidden, then the corresponding headings are hidden as well.
function handle_dsc() {
	$('.t-dsc').each(function() {
		var member = $(this).find('.t-dsc-member-div');
		if (member[0]) {
			var lines = member.find('> div:nth-child(2) > .t-lines').children();
			var mems = member.find('> div:first-child .t-lines').children();
			if (lines.length !== mems.length)
				this.hidden = !should_be_shown(lines.children('.t-mark-rev'));
			else {
				lines.each(function(i) {
					var marker = $(this).children('.t-mark-rev');
					mems[i].hidden = !should_be_shown(marker);
					marker.hidden = !should_be_shown(marker);
				});
				this.hidden = all_hidden(mems);
			}
		} else {
			var marker = $(this).find('> td:first-child > .t-mark-rev');
			this.hidden = !should_be_shown(marker);
		}
	});
	$('.t-dsc .t-dsc-header').each(function() {
		var marker = $(this).find('> td > div > .t-mark-rev');
		var lastheader = $(this).nextUntil(':not(.t-dsc-header)').addBack();
		this.hidden = all_hidden(lastheader.nextUntil(':not(.t-dsc)')) || !should_be_shown(marker);
	});
	var heading_selector = ['tr:has(> td > h5)', 'tr:has(> td > h3)'];
	$.each(heading_selector, function(i, selector) {
		$(selector).each(function() {
			var section = $(this).nextUntil(heading_selector.slice(i).join(','));
			this.hidden = all_hidden(section.filter('.t-dsc'));
		});
	});
	$('.t-dsc-begin').each(function() {
		this.hidden = all_hidden($(this).find('.t-dsc'));
	});
}
// Hide or show the navbar elements expanded from the {{nv ...}} template family. See documentation
// at https://en.cppreference.com/w/Template:nv/doc .
// A line of revision marker only controls a single entity name, even if it's expanded from
// {{nv ln | ... }} that contains multiple lines.
// If a heading contains a revision marker, that revision marker controls the visibility of the
// heading and its corresponding contents; otherwise the heading is hidden when it is followed by
// content elements, and all of them are hidden.
function handle_nv() {
	$('.t-nv').each(function() {
		var marker = $(this).find('> td > .t-mark-rev');
		this.hidden = !should_be_shown(marker);
	});
	$('.t-nv-ln-table').each(function() {
		var lines = $(this).find('> div:nth-child(2) > .t-lines').children();
		var mems = $(this).find('> div:first-child .t-lines').children();
		lines.each(function(i) {
			var marker = $(this).children('.t-mark-rev');
			if (mems[i]) mems[i].hidden = !should_be_shown(marker);
			marker.hidden = !should_be_shown(marker);
		});
		this.hidden = all_hidden(mems);
	});
	var heading_selector = ['.t-nv-h2', '.t-nv-h1'];
	$.each(heading_selector, function(i, selector) {
		$(selector).each(function() {
			var section = $(this).nextUntil(heading_selector.slice(i).join(','));
			var marker = $(this).find('> td > .t-mark-rev');
			if (marker[0]) {
				section.each(function() {
					this.hidden = this.hidden || !should_be_shown(marker);
				});
				this.hidden = !should_be_shown(marker);
			}
			this.hidden = all_hidden(section.find('.t-nv-ln-table'));
		});
	});
}
// Hide or show the elements expanded from the {{rev ...}} template family. See documentation at
// https://en.cppreference.com/w/Template:dcl/doc .
// Borders are handled by class stdrev-rev-hide.
function handle_rev() {
	$('.t-rev, .t-rev-inl').each(function() {
		this.hidden = !should_be_shown(this);
	});
}
// Hide or show headings.
// If the heading contains a revision marker, that revision marker controls the visibility of it
// and its corresponding contents; otherwise, a heuristic is made: if the contents contain a dsc
// list, and its revision-related contents are hidden, then the heading and all contents are hidden
// as well.
// The heuristic requires that handle_dsc() and handle_rev() have been called.
function handle_headings() {
	var heading_selector = ['h5', 'h4', 'h3', 'h2'];
	$.each(heading_selector, function(i, selector) {
		$(selector).each(function() {
			var section = $(this).nextUntil(heading_selector.slice(i).join(','));
			var marker = $(this).find('> span > .t-mark-rev');
			if (marker[0]) {
				section.each(function() {
					this.hidden = this.hidden || !should_be_shown(marker);
				});
				this.hidden = !should_be_shown(marker);
			}
			if (section.is('.t-dsc-begin') && !section.is(':not(p, .t-rev-begin, .t-dsc-begin)')) {
				var revisioned_content = section.find('.t-dsc, .t-rev, .t-rev-inl');
				section.each(function() {
					this.hidden = this.hidden || all_hidden(revisioned_content);
				});
				this.hidden = all_hidden(revisioned_content);
			}
		});
	});
}
// Hide or show <li> elements based on the contained revision markers.
function handle_list_items() {
	$('li').each(function() {
		var marker = $(this).children('.t-mark-rev');
		this.hidden = !should_be_shown(marker);
	});
}
})();

Features include:

1. hide section based on revision markers in the heading
2. hide <li> based on its contained revision markers
3. hide "Defined in header ..." when the corresponding entities are hidden
4. implement renumbering inside {{v}}
5. much shorter than P12's implementation! (~300LOC vs ~1800LOC)

Does it make sense to include this as an "official" gadget?

--223.3.167.101 10:25, 3 March 2019 (PST)

We don't want to have two gadgets for the same thing. What does the current gadget do that this script doesn't, and vice versa? What caused the drastic shortening? T. Canens (talk) 11:07, 23 March 2019 (PDT)

> What does the current gadget do that this script doesn't

1. be hosted on GitHub

2. have tests

With regard to functionality, I don't know of any case that is handled better by Gadget-StandardRevision than by this script, but I don't have a thorough test.

> and vice versa?

All features mentioned above. Also, it does not have the problem reported below: Gadget-StandardRevision ignores all except the first revision marker in a row, and behaves unintuitively when the markers occupy more rows than the names in the dsc item. This script takes care to handle these cases better.

> What caused the drastic shortening?

Gadget-StandardRevision clones each of the elements that may be affected by the Gadget, and has a complex data structure to keep track of these elements and their clones. A lot of work is done to construct, manipulate, and debug this data structure. By contrast, this implementation directly manipulates the affected elements, which requires much less lines of code.

--121.249.15.21 10:52, 24 March 2019 (PDT)

The current gadget is also hosted on GitHub and has tests https://github.com/p12tic/cppreference-doc --Ybab321 (talk) 10:30, 26 March 2019 (PDT)

Right, so I listed it as a thing that the current gadget do that this script doesn't :) --121.249.15.75 11:38, 26 March 2019 (PDT)

Oops, my mistake :( --Ybab321 (talk) 06:44, 31 March 2019 (PDT)

Search: noreturn - does not find en.cppreference.com/w/cpp/language/attributes/noreturn

How can I update the search system?

Several times I have searched for terms & not found them only to Google them & be given a cppreference page.

Also `Search: fallthrough` does not find en.cppreference.com/w/cpp/language/attributes/fallthrough.

And `Search: if constexpr` does not find en.cppreference.com/w/cpp/language/if.

I’m sure that there are more ...

Chris0 (talk) 18:50, 5 March 2019 (PST)

Updating the Embarcadero column

I'm a newly registered user, so cannot edit this page as it's under protection.

The Embarcadero column for C++14 and C++17 is out of date. The compiler supports all of C++14, and all of C++17 bar:

• Replacement of class objects containing reference members P0137R1
• Standardization of Parallelism TS P0024R2
• Elementary string conversions P0067R5
• Splicing Maps and Sets P0083R3
• Hardware interference size P0154R1

More info here: http://docwiki.embarcadero.com/RADStudio/Rio/en/Modern_C%2B%2B_Language_Features_Compliance_Status#C.2B.2B14_Features and http://docwiki.embarcadero.com/RADStudio/Rio/en/Modern_C%2B%2B_Language_Features_Compliance_Status#C.2B.2B17_Features

yes, their new compilers are basically Clang: Embarcadero 10.1 is Clang 3.3, Embarcadero 10.3 (linked above) is Clang 5.0. But I suppose it's fair to update the table (for now, I updated the links below the table) --Cubbi (talk) 06:40, 8 March 2019 (PST)

Standard Revision gadget problems with C++20

It seems there are some problems with displaying (not displaying) features removed in C++20, On std::allocator page choosing C++20 Standard to be displayed, every removed feature is still on the list, marked as deprecated, information "removed in C++20" disappears. Is this template problem or widget problem? Kaznov (talk) 09:38, 15 March 2019 (PDT)

Shall we clarify on copy functions of standard exception classes?

I've added corresponding contents myself. --Fruderica (talk) 23:14, 25 April 2020 (PDT)

sizeof parameter can't be a C-style cast

I'm not able to make this change, but would like to suggest it.

sizeof's notes ought to say something like:

With form (2), expression cannot be a C-style cast, due to ambiguity with form (1). In other words, sizeof (char)+1 is parsed as (sizeof(char)) + 1, rather than sizeof((char)+1). — Preceding unsigned comment added by Myria (talk • contribs)

std::sort() should mention strict weak ordering requirements

The description of std::sort() does not mention that the comparison operator comp must define a strict weak ordering. Unless the standard has changed, it is undefined behavior to sort with a comparison function which does not define a strict weak ordering.

It also is probably worthwhile to explicitly point out that sorting with a comparison function that does not define a strict weak ordering is undefined behavior, and in fact in common implementations can lead to a crash or infinite loop, since it's a really commonly-encountered pitfall.

It may also be worthwhile pointing out that operator< does *not* define a strict weak ordering over floating point values due to NaN behavior, and so std::sort() may crash when applied to a vector of floating point values.

I believe that std::stable_sort() has implementation defined behavior rather than undefined when there's not a strict weak ordering, so it might also be worthwhile recommending using std::stable_sort() in such cases.

SethML (talk) 10:41, 9 April 2019 (PDT)

cpp/algorithm/sort says "Compare must meet the requirements of Compare." and cpp/named_req/Compare explains strict weak ordering and all other requirements on the comparison function. I suppose it could be highlighted, something like "must meet the requirements of Compare, including the strict weak ordering requirement", but then it sounds like there are cases where the ordering is not included. Maybe a concise bad example would be worth adding.

As for stable_sort, the actual requirement uses the word of power "shall"], so it's undefined to violate that for both sort and stable_sort. --Cubbi (talk) 11:12, 9 April 2019 (PDT)

Indeed, I've been reading the standards and discovering these things. I'd had this assumption that stable_sort() was implementation-defined over poorly-ordered sequences, but it appears that it's actually undefined and could crash. In practice I think most implementations are a merge sort, which should have some reasonable behavior given input which isn't strict weak ordered. But the standard doesn't guarantee that, sadly.

The phrasing in the standard is: For algorithms other than those described in alg.binary.search, comp shall induce a strict weak ordering on the values.

I'd missed that the Compare requirement encoded the strict weak ordering requirement - that's pretty subtle. I do think that for all of the sort functions, it'd be nice to expand the compare bullet point, something like:

* Compare must meet the requirements of Compare, including the strict weak ordering requirement. If it doesn't the behavior of X_sort is undefined.

A bad example using floating point could be a good way to call out UB with floating point collections, since that's a serious gotcha.

I find it also an interesting question what the behavior of lower_bound and friends is if passed a sequence that is not partitioned with respect to the value being searched for. The standard does not use the word "shall" - it says: All of the algorithms in this subclause are versions of binary search and assume that the sequence being searched is partitioned with respect to an expression formed by binding the search key to an argument of the comparison function. What is your interpretation of the result if the sequence is not partitioned - undefined behavior, or implementation defined?

"implementation-defined" is an additional standard requirement, not made here. I would say "undefined". If you feel strongly enough about it, consider raising an editorial issue on whether 'assume' in [alg.binary.search]/1 means the same as 'shall' in [alg.sorting]/3, and what does it mean to violate it (ill-formed? undefined? unspecified?) --Cubbi (talk) 06:54, 10 April 2019 (PDT)

Also, if I comment on [Talk:Main_Page/suggestions] enough, will I gain edit access? --SethML (talk) 12:11, 9 April 2019 (PDT)

Definintion of synchronizes-with in cpp/atomic/memory order?

The page cpp/atomic/memory order tries to be fairly formal with defining the different types of memory ordering constraints, but a definition for "synchronizes-with" (which "inter-thread happens-before" depends on) appears to be missing.

more copy & pastable header

On all the pages at the top it says "Defined in <X>". I think it would be better to do "#include <X>" instead so I can copy & paste that into my code directly.

135.23.100.188 12:00, 21 April 2019 (PDT)Ben

search widget takes me to wrong page when searching for restrict

Entering "restrict" into the search widget at the top of the page, takes you to https://en.cppreference.com/w/cpp/memory/gc/get_pointer_safety rather than https://en.cppreference.com/w/c/language/restrict

Not all error_codes are platform-dependent

In https://en.cppreference.com/w/cpp/error error_condition and error_error are described as:

error_condition (C++11) holds a portable error code

error_code (C++11) holds a platform-dependent error code

But that doesn't seem to be correct. See for example https://akrzemi1.wordpress.com/2017/07/12/your-own-error-code/#comment-6921 or http://blog.think-async.com/2010/04/system-error-support-in-c0x-part-2.html

The descriptions are from overviews in the standard, see syserr.errcode.overview and syserr.errcode.overview. If you want to add something about the actual usage, I think we can add a "Notes" section to describe it. (By the way, the second article was written before C++11 so I doubt whether it is useful now.) --Fruderica (talk) 07:45, 27 April 2019 (PDT)

open source libs

How to add reference to open source lib? (Alex25 (talk) 01:20, 28 April 2019 (PDT))

Improving this site

I'm hardly a new user... can't I get edit rights (back)? CarloWood (talk) 09:18, 28 April 2019 (PDT)

BNFLite

Could you add nice BNFLite parsing h-library ( https://github.com/r35382/bnflite) into Text::Parse section

Language support page: list library support with the library name not the compiler name

The language support page lists compiler names in the list of library features. In a lot of Linux distributions, Clang will by default use GCC's libstdc++ instead of LLVM's libc++, which means that the relevant column to look at in that table for support when using Clang is the GCC column, not the Clang column. Likewise, clang-cl will use MSVC's standard library by default. (I think Intel's compiler behaves similarly to Clang in this regard, and indeed probably several other compilers in the table are not coupled to a particular standard library implementation.)

The current table structure seems less helpful than it could be.

Suggestion: rename the GCC column to libstdc++ and the Clang column to libc++; remove the columns for compilers that don't have their own standard library implementation; add introductory text explaining which standard library each compiler uses by default.

zygoloid (talk) 17:12, 4 May 2019 (PDT)

this has been suggested as far back as 2016 Talk:cpp/compiler_support#Splitting_and_folding the_table and I don't think there is any opposition. Someone just needs to volunteer. --Cubbi (talk) 06:08, 6 May 2019 (PDT)

Now I have placed core language features and library features into different tables, and renamed the columns when listing library features. However I think the introductory might be a hard work, since the compilers' default usage of standard library implementation is not well-documented. --Fruderica (talk) 21:54, 6 May 2019 (PDT)

Equivalence of the signature of function objects

Hi,

the documentation of (e.g.) std::accumulate says:

 op The signature of the function should be equivalent to the following:

    Ret fun(const Type1 &a, const Type2 &b);

The signature does not need to have const &.

When is a signature "equivalent" to the above? 2001:B01:2404:4:0:0:0:57 23:49, 9 May 2019 (PDT)

This is handwaving vigorously. The basic requirement is that a set of expressions must work. But of course that's a bit abstract and we want to show what a function (object) that meets the requirement should look like. Hence the weasel-wording. Perhaps we should rephrase the requirements in terms of the required expressions, and then show sample signatures as examples? T. Canens (talk) 20:23, 17 May 2019 (PDT)

operator :: – ( I cannot edit https://en.cppreference.com/w/Talk:cpp/language/operator_precedence where it belongs to)

At https://en.cppreference.com/w/cpp/language/operator_precedence the token :: that is used to build nested names is listed as an "operator". But AFAIK this token is not an operator (or a very special one).

Because for any (binary) operator ★ the term A★B★C either means (A★B)★C _or_ A★(B★C) and you might add (…) to change the meaning.

But for :: you can't do this, because A::(B::C) does not compile, and (A::B)::C compiles, but is parsed as a type cast of ::C into the type A::B. :-/

What do you think? Should it be changed or at least mentioned? --Roker (talk) 04:01, 13 May 2019 (PDT)

the whole table is a loose approximation of expression grammar in human-readable terms of "precedence" and "associativity". These terms do not appear anywhere in the language specification, they are invented by the authors of the table. In the expression grammar, :: combines identifiers into primary expressions, so inasmuch as the grammar can be expressed in those terms, it has the "highest precedence". We could drop it, but then people used to seeing precedence tables from other sources such as enwiki:Operators_in_C_and_C++#Operator_precedence would say cppreference's table is incomplete and add it back. --Cubbi (talk) 06:40, 13 May 2019 (PDT)

They can already say that since cppreference's table does not include const_cast et al, though.

OTOH, the standard calls :: an operator in [over.oper]/3. --D41D8CD98F (talk) 11:06, 14 May 2019 (PDT)

Add reference to paragraph about automatically generated class member functions

Hi there.

In https://en.cppreference.com/w/cpp/language/classes, I suggest in the last paragraph we add references to the rule of zero/three/five.

The very last sentence says:

"Some member functions are special: under certain circumstances they are defined by the compiler even if not defined by the user."

This would be an optimal place to refer to the rule of zero/three/five (link: https://en.cppreference.com/w/cpp/language/rule_of_three).

217.10.52.10 05:02, 13 May 2019 (PDT) André Malcher

Help to translate

Eu gostaria de ajudar a traduzir as páginas para o português do Brasil, por que tem grande diferenças do de Portugal.

Gostaria de saber como posso fazer isso?

Add argument types in the examples

https://en.cppreference.com/w/cpp/io/c/fprintf

Stupidly enough, despite the extensive examples, there is none using the argument types (e.g. %lu)

Add AI TP\O CURRlink title

https://ai.stackexchange.com/questions/6185/why-does-c-seem-less-widely-used-in-ai[1]

Add AI libraries for c++.

https://ai.stackexchange.com/questions/6185/why-does-c-seem-less-widely-used-in-ai[2]

AI using C++...

[ai.stackexchange.com/questions/6185/why-does-c-seem-less-widely-used-in-ai] is the source of the following. I have inserted links to the libraries web sites. You don't need a powerful language for programming AI. Most of the developers are using libraries like Keras,[keras.io] Torch [torch.ch], Caffe,[caffe.berkeleyvision.org] Watson [cloud.ibm.com/developer/watson/dashboard], TensorFlow,[www.tensorflow.org] etc. Those libraries are highly optimized and handle all the though work, they are built with high performance languages, like C. Python is just there to describe the neural network layers, load data, launch the processing and display results. Using C++ instead would give barely no performance improvement, but would be harder for non-developers as it require to care for memory management. Also, several AI people may not have a very solid programming or computer science background.

Another similar example would be game development, where the engine is coded in C/C++, and, often, all the game logic scripted in a high level language. Ian Martin Ajzenszmidt (talk) 05:39, 18 May 2019 (PDT)

Add See also: reference to <iomanip> from std::string?

Just a stray thought for improved navigation. For new C++ users that find themselves at [std::basic_string](https://en.cppreference.com/w/cpp/string/basic_string) and the next place many would need to go a majority of the time would be to <iomanip>. Would it be worth adding a ***See Also:*** reference to <iomanip>. Especially for those who do not yet know <iomanip> exists. Drankinatty (talk) 18:26, 18 May 2019 (PDT)

cpp/language/operator_comparison

first sentence of the the section Notes currently is:

Because these operators group left-to-right, the expression a<b<c is parsed (a<b)<c, and not a<(b<c) or (a<b)&&(b<c).

but the following would be clearer to understand:

Because these operators group left-to-right, the expression a<b<c is parsed (a<b)<c, and neither a<(b<c) nor (a<b)&&(b<c).

where can be donations be sent?

Hello ! I read about the donations, can you give me please more informations about whre can the donations be made? it will be very usefull. Thanks ! Sorry for disturbing the discussion page -Giani

contradiction in definition of std::filesystem::weakly_canonical

In the description of std::filesystem::weakly_canonical, it is stated that the parameter p must be an existing path. This is in contradiction with the description of the function std::filesystem::weakly_canonical, that states that p can consist of an existent left-hand-side and a non-existent right-hand-side.

Parallelism TS 2

• https://en.cppreference.com/w/cpp/experimental/simd needs to be linked from https://en.cppreference.com/w/cpp/experimental/parallelism_2.
• https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/simd/abi_for_size needs to be renamed (as happend in the WD before the TS was published) to simd_abi::deduce.
• Most of the simd documentation needs to either be updated to TS state or written.
• I could help (author of that part of the TS).

Vir (talk) 03:12, 27 May 2019 (PDT)

First two bullets are done. --Fruderica (talk)

suggestion for the Private Inheritance section

this sentence is hard to read:

Using a member offers better encapsulation and is generally preferred unless the derived class 
requires access to protected members (including constructors) of the base, needs to override a 
virtual member of the base, needs the base to be constructed before and destructed after some 
other base subobject, needs to share a virtual base or needs to control the construction of a 
virtual base.

this is much easier, using a list:

Using a member offers better encapsulation and is generally preferred unless the derived class:
--requires access to protected members (including constructors) of the base
--needs to override a virtual member of the base
--needs the base to be constructed before and destructed after some other base subobject
--needs to share a virtual base or needs to control the construction of a virtual base

75.142.108.70 14:01, 2 June 2019 (PDT)

Suggested addition for std::time page

Please add links to the following pages in the "See also" section of https://en.cppreference.com/w/cpp/chrono/c/time

https://en.cppreference.com/w/cpp/chrono/c/asctime https://en.cppreference.com/w/cpp/chrono/c/strftime

139.181.7.34 16:30, 4 June 2019 (PDT)

the headline for the non-throwing deletes is incorrect

functions 9-12 are headlined as placement versions, whereas they are non-throwing versions.

new(nothrow) is placement-new by expr.new/15 --Cubbi (talk) 05:07, 6 June 2019 (PDT)

now I see, cpp/memory/new/operator_new calls them "replaceable non-throwing", while cpp/memory/new/operator_delete calls them "replaceable placement".. Perhaps "non-throwing" is more user-friendly even if all of them are actually non-throwing --Cubbi (talk) 06:41, 6 June 2019 (PDT)

Only for multidimensional arrays?

I think the description should read "(potentially multidimensional) array" instead of "multidimensional array".

Can a standard exception object embed a fixed-size array?

The documentation for e.g. std::runtime_error, at

 <https://en.cppreference.com/w/cpp/error/runtime_error>,

states:

 "Because copying std::runtime_error is not permitted to throw exceptions,
  this message is typically stored internally as a separately-allocated
  reference-counted string."

Would it be OK to store the message into an array data member? That means that the string could have to be truncated, so the question is whether having a maximum length falls under possible implementation-defined limits. 37.182.205.198 03:06, 13 June 2019 (PDT)

The string cannot be truncated because of the post-condition. Though I think that constructors of std::runtime_error taking const char* and const std::string& are still permitted to throw exception if the string is too long, and an array of char embedded in the exception object is also permitted --Fruderica (talk) 03:55, 13 June 2019 (PDT)

std::size_t error in example

Reverse iteration. Unsigned variable taking values lower than 0.

   for (std::size_t i = a.size()-1; i < a.size(); --i)

Should be:

   for (std::size_t i = a.size()-1; i >= 0; --i)

std::size_t is an unsigned integer type, so i >= 0 always holds and the loop you suggested is endless. On the other hand, if i == 0 then --i make i equals to the maximum value of std::size_t which is almost always larger than a.size(), so the loop will reach its end. If you don't like this, something like for (std::size_t i = a.size(); i != 0;) { --i;/*...*/} might be useful. --Fruderica (talk) 04:56, 21 June 2019 (PDT)

Typo on std::iterator page

Hi,

In the example section of the std::iterator page it says '.. _a_ input iterator ..' which should be '.. _an_ input iterator ..'.

Thanks for the truly excellent resource that is cppreference.

Best regards,

Kris van Rens 5.132.118.36 13:44, 22 June 2019 (PDT)

Enum syntax: trailing semicolon

It appears that on the enum declaration page, a trailing semicolon is missing at various places for the enum declarations.

cpp/utility/functional/bind/example

the following line is wrong:

   f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused

and it should be:

   f1(1, 2, 1001); // 1 is bound by _2, 2 is bound by _1, 1001 is unused

Rob42 (talk) 07:55, 9 July 2019 (PDT)

I believe the comment is correct as is, but given [3], [4], [5], [6] (all of them are wrong edits to the example) this line seems to have confused a lot of readers. I've edited the example in the hope to make it harder to misunderstand. --D41D8CD98F (talk) 10:26, 9 July 2019 (PDT)

Replace dead link in rule of three page with archive.org link

The link to the original source for the "rule of zero" on the page https://en.cppreference.com/w/cpp/language/rule_of_three is dead.

Perhaps change https://rmf.io/cxx11/rule-of-zero to https://web.archive.org/web/20160602100235/https://rmf.io/cxx11/rule-of-zero/

73.8.19.235 09:19, 10 July 2019 (PDT)joe

errno and strto* examples

On some examples, like strtol, errno is not reset before calling the function and is checked after an intermediate call to other functions, such as printf, which can set errno itself.

Although it is not relevant for the correct execution of the example, IMHO those code snippets should be a vehicle for promoting good practices. So I suggest to clear errno before calling strto* and test (or save) it immediately after the call.

79.151.6.162 10:19, 11 July 2019 (PDT)oscarfv

Subsume is synonym for implies.

On TS variant of concepts at: https://en.cppreference.com/w/cpp/experimental/constraints

You have inconsistency in your definitions/use of the word subsumes. Subsumes is synonym for implies by your first definition. (and also by C++20 standard version of concept https://en.cppreference.com/w/cpp/language/constraints)

1) "Concept P is said to subsume concept Q if it can be proven that P implies Q"

2) "A subsumes a conjunction A&&B and does not subsume a disjunction A||B"

But

Mathematically in truth/boolean logic this is tautology for conjunction (always true):

A&&B implies  A 

and also always

A&&B implies  B 

so by first definition of word 'subsume' the second statement above should be other way around

A&&B subsumes A

and also mathematically for disjunction (boolean logic):

A implies A||B  

and also

B implies A||B

Now replace word implies for subsumes in those statements and you get contradiction again to your second statement 2).

Also note:

 A||B does not imply A
 A||B does not imply B

so again does not subsume.

On another note: You derive class to model 'is-a' relationship or subset relationship. You narrow down original big class of animals.

class Cat:Animal {}

Cat is an animal. Set of cats is subset of set of all animals.

Or you have implication "x is a cat implies x is an animal" , but not otherway around 'x is animal' does not imply 'x is a cat'. In concept language: Cat is additional constraint on top of animal. (Moveable and meowavle) and additional constraint makes class smaller subset and smaller subset means. So you either say Animal set subsumes Cats sub-set. Or you use 'subsume' for the characteristics (like in concepts). Cat characteristic subsumes Animal characteristics (x is a cat assumes/implies/subsumes x is a living being).

@ sign is displayed in place of overloaded operators

Sorry about the previous message, I accidentally posted an edited page instead of the suggestion.

Edit suggestion: @ sign is being displayed instead of operators !, << and ++ in Overloaded Operators section.

overload resolution links in using-declaration

In the inheriting constructors section of the using_declaration it would be great to add a link when overload resolution is mentioned.

unique_ptr better example

Hi! I think this example will be helpful on `std::unique_ptr` page. Somehow, I always struggle to remember that usage.

 struct MyDeleter {
   void operator ()(int *val) {
     delete[] val;
   }
 };
 typedef std::unique_ptr<int, MyDeleter> my_ptr;
 int main(int, char**)
 {
   my_ptr x(new int[10]);
 }

I think it would be better to using std::unique_ptr<int[]>. --Fruderica (talk) 20:18, 26 July 2019 (PDT)

Strong ordering does not allow equivalence

I believe https://en.cppreference.com/w/cpp/utility/compare/strong_ordering is incorrect in listing "equivalent" as one of the possible values. Gio (talk) 19:57, 28 July 2019 (PDT)

It allows. --Fruderica (talk) 01:53, 29 July 2019 (PDT)

Right, thank you. But, then, shouldn't at least the descriptions for "equal" and "equivalent" be different? Gio (talk) 12:55, 29 July 2019 (PDT)

But they aren't different in this case. equivalent = equal --Cubbi (talk) 13:45, 29 July 2019 (PDT)

final specifier example typo

A::foo() comment should be fixed to: // Base::foo is overridden and it is the final override

Zhesson (talk) 09:27, 30 July 2019 (PDT)

Fixed. --Fruderica (talk) 03:23, 31 July 2019 (PDT)

FLT_MAX_EXP definition typo in climits

The current definition

This is incorrect; the similar page for C has the correct definition:

maximum positive integer such that FLT_RADIX raised by power one less than that integer is a normalized...

Fixed. --Fruderica (talk) 03:23, 31 July 2019 (PDT)

Unqualified name lookup->Class definition

I think a, c is incorrect because of class scope and his accessing rules - all names defined in class is available in entire class even if declaration is put below instruction of use.

d - if class is nested into another class then entire outer class will be searching and if name will still not found then local scope until definition class - because function accessing rules.

the rules you're describing are a little lower, in cpp/language/unqualified_lookup#Member_function_definition --Cubbi (talk) 08:23, 2 August 2019 (PDT)

std::basic_fstream<CharT,Traits>::swap Example

https://en.cppreference.com/mwiki/index.php?title=cpp/io/basic_fstream/swap&oldid=50835 Example:

bool Create(string path, fstream & fs) {
			try {
				fstream fst(path, ios::binary | ios::trunc | ios::in | ios::out);
				if (!fst.is_open())
					return false;
				fst.swap(fs);
				return true;				
			}
			catch (...) {
				return false;
			}
		}

use

int main(void) {
	fstream fs;
	string path = "E:\\Downloads\\x125\\Cpp11.pdf";
	if(File::Create(path, fs))
		fs.write(path.c_str(), path.length());	
	return 0;
}

— Preceding unsigned comment added by Rsarov (talk • contribs) 08:29, 2 August 2019‎ (PDT)

✔ Copied (with modifications) to fstream/swap page.--Space Mission (talk) 08:13, 16 June 2021 (PDT)

Concepts: PascalCase --> standard_case

Perhaps add a note about P1754 R0: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1754r0.pdf

r1. And I think we're waiting for it to be actually merged into the draft (it's PR 3099 --Cubbi (talk) 05:04, 5 August 2019 (PDT)

main() is indented 4 spaces. Unlike the rest. Please make that 2 spaces.

main() is indented 4 spaces. Unlike the rest. Please make that 2 spaces.

PS Can't I get edit rights? I'm not vandalizing, so...

C fwrite missing error behaviour regarding file position.

If an error occurs, the resulting value of the file position indicator for the stream is indeterminate.

13.236.57.85 01:41, 6 August 2019 (PDT)

inconsistent find/rfind description

I don't think "find characters" is good wording for find on the main page of basic_string, should be "find substring" (or "find character sequence" as it's put in https://en.cppreference.com/w/cpp/string/basic_string/find) in order to avoid confusion with find_first_of. Also find/rfind titles should be consistent imo, "find the first/last occurrence of a substring" seems to be a good fit

https://en.cppreference.com/w/cpp/string/basic_string

find: "find characters in the string" rfind: "find the last occurrence of a substring"

180.183.72.126 22:38, 6 August 2019 (PDT) Vitaly

Memory leak in example on https://en.cppreference.com/w/cpp/locale/numpunct

I think the "new french_bool" in the example of https://en.cppreference.com/w/cpp/locale/numpunct leads to a memory leak so I would suggest to use a locale variable which can be freed at the end.

Best regards Stefan

195.242.227.17 03:07, 7 August 2019 (PDT)

Please read this note. --Fruderica (talk) 03:50, 7 August 2019 (PDT)

Duplication for feature testing macros

The table cpp/preprocessor/replace#Language_feature-testing_macros duplicates cpp/feature_test#Language_features (with less information). It should be replaced by a link, e.g.:

Ecatmur1 (talk) 04:17, 7 August 2019 (PDT)

Template:cpp/container/lower bound

Add "(i.e. greater or equal to)" after "that is not less than" (like the text on cpp/algorithm/lower bound).

tuple page's forward_as_tuple description not accurate

"forward_as_tuple creates a tuple of rvalue references "

It should be forwarding references rather than rvalue references

Fixed. --Fruderica (talk) 08:42, 7 August 2019 (PDT)

error in the example code for std::filesystem::create_directory

The line fs::permissions("sandbox/1/2/b", fs::perms::remove_perms | fs::perms::others_all); does not compile.

It should rather be

fs::permissions("sandbox/1/2/b", fs::perms::others_all, fs::perm_options::remove);

- David Bellot (talk) 16:15, 7 August 2019 (PDT)

Fixed. --Fruderica (talk) 04:05, 8 August 2019 (PDT)

Complexity of set algorithms

The complexity of all set operations (std::includes, std::set_difference, etc) is listed as follows:

At most 2·(N₁+N₂-1) comparisons, where N₁ = std::distance(first1, last1) and N₂ = std::distance(first2, last2)

This is different from the text in the standard (§ 23.7.6.1), which states:

Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons.

The equation should be changed to 2·(N₁+N₂)-1 to match the standard.

Ryan Brown (talk) 12:59, 9 August 2019 (PDT)

✔ Done Finally fixed, i.e. +1 in std::includes. Thnx.) --Space Mission (talk) 16:26, 10 October 2023 (PDT)

Vertical propagation of allocators

The vertical propagation allocators is documented very poorly.

The std::std::scoped_allocator_adaptor<OuterAlloc, InnerAlloc...> documentation gives the impression that it can be used with any allocator, however, it miserably fails when used together with std::polymorphic_allocator<T> (see [1]). On the other hand, std::polymorphic_allocator<T> already has the capabilities to propagate the allocator vertically as noted in [1], however, this is only noted in the constructor of the allocator, so this is very easy to miss.

My concrete suggestion is:

• Add a note in the std::std::scoped_allocator_adaptor<OuterAlloc, InnerAlloc...> saying that this is not needed when OuterAlloc is a std::polymorphic_allocator<T>.
• Promote and clarify the note in std::polymorphic_allocator<T>::construct(...) to std::polymorphic_allocator<T> so that it is clear that child continer-like objects will have the same allocators as the parent.

[1]: https://stackoverflow.com/questions/54654606/c-cant-propagate-polymorphic-allocator-with-scoped-allocator-adaptor

129.206.107.164 09:57, 10 October 2023 (PDT) sospinar

good observeration; cpp/memory/polymorphic_allocator already says "the elements of a container using a polymorphic_allocator will use that same allocator for their own allocations" - I'll add a symmetric comment to cpp/memory/scoped_allocator_adaptor --Cubbi (talk) 15:04, 10 October 2023 (PDT)

Cleaning up vandalism

The admin forgot to delete this page after banning the IP that made it. --88.197.36.217 06:02, 11 October 2023 (PDT)

Suggestion for clarity

The description for the return value contains the phrase, "Nonzero integral value if arg is negative." While technically correct, I think it's worth considering changing "integral" to "integer." ZephyrCubic (talk) 14:34, 11 October 2023 (PDT)

this is about c/numeric/math/signbit which is actually shown in C99 and C11 synopsis with a return type of type int, so I agree, "integer" would be more to the point. --Cubbi (talk) 20:28, 11 October 2023 (PDT)

overflow_error exception's example

In the page [7] we have an example to show the usages of the overflow_error exception. In this example the program throws overflow_error for all types of error, such as underflow. I think it is better to use the related ones instead. 18:24, 11 October 2023 (PDT) Erfan Vahabi

✔ Done Quite reasonable, it's been updated. Although for this example std::length_error would be a more appropriate type. --Space Mission (talk) 13:58, 12 October 2023 (PDT)

Bug (typo) in header/complex page

Missing parenthesis ( in operator== at https://en.cppreference.com/w/cpp/header/complex

   template<class T> constexpr bool operator==
       const complex<T>&, const complex<T>&);

Thanks. Fixed ✔ Done --Ybab321 (talk) 10:05, 12 October 2023 (PDT)

std::ranges::views::common: slightly broken syntax highlighting

On the page https://en.cppreference.com/w/cpp/ranges/common_view, 2) the second bullet point: `common_view{e}`, the closing brace is not correctly formatted.

Thanks. Fixed ✔ Done --Ybab321 (talk) 10:05, 12 October 2023 (PDT)

Wrong example for strcoll

In c/string/byte/strcoll and cpp/string/byte/strcoll the example seems to be wrong. It says that "hrnec" comes before "chrt" in the Czech locale but running the code results in "chrt" before "hrnec". I don't speak Czech so I don't know if the note is wrong and that behavior is correct, but either way the examples should be fixed. --2A02:586:292B:EA3D:14FD:E819:1ED3:469C 11:29, 13 October 2023 (PDT)

✔ Done The examples were updated with "utf8". They are correct, but depend on installed LC_* files, etc.

E.g. on some POSIX OS it could be:

   /usr/lib/locale:
   ...
   /usr/lib/locale/cs_CZ
   /usr/lib/locale/cs_CZ.utf8
   ...
   /usr/lib/locale/cs_CZ/LC_ADDRESS
   /usr/lib/locale/cs_CZ/LC_COLLATE
   ...
   /usr/lib/locale/cs_CZ.utf8/LC_COLLATE

While on coliru's Ubuntu Linux ls -R /usr/lib/locale prints:

 /usr/lib/locale:
 C.UTF-8
 ...
 /usr/lib/locale/C.UTF-8:
 ...
 LC_COLLATE

 /usr/lib/locale/C.UTF-8/LC_MESSAGES:
 SYS_LC_MESSAGES

Meaning that the Czech locales are not installed.) --Space Mission (talk) 13:11, 13 October 2023 (PDT)

Abstract class

An abstract class is one that cannot be instantiated. The page for abstract class correctly states this at the top. Later it implies that it must have a pure virtual function. This is not true and is also a common misconception. A class can have a protected default constructor or an undeclared default constructor to force it to be abstract. Also it will not have any other public constructor, ignoring copy/move constructors.

An abstract class must have a pure virtual function --Ybab321 (talk) 13:11, 15 October 2023 (PDT)

That is the common misconception. P121 of C++ Move Semantics says it is also forced by an undeclared default constructor.

If so, then the book is incorrect and you should let the author know along with the above citation --Ybab321 (talk) 04:37, 16 October 2023 (PDT)

The standard only uses the term abstract base class once while describing std::basic_streambuf. The need to be derived from is the essential concept. The method used is to make the constructors protected. There is not any pure virtual function. It is not clear why there is not a pure virtual function.

The plot thickens... I've raised an issue accordingly --Ybab321 (talk) 03:12, 19 October 2023 (PDT)

I was thinking that the pure virtual function method of making a class an ABC is not a straightforward method. The keyword final ensures that a class is not inherited but there could be another keyword to ensure it is inherited.

Forward declaring enums in C

c/language/enum says "...there are no forward-declared enums in C". However, C23 in 6.7.2.2 /6 explicitly allows a forward-declaration of an enum as long as the underlying type is specified ("An enum specifier of the form enum identifier enum-type-specifier may not appear except in a declaration of the form enum identifier enum-type-specifier ; ...") --2A02:586:292B:EA0E:E08F:CE97:FFEA:E15E 06:20, 15 October 2023 (PDT)

Forgot to mention that the example at 6.7.2.2/18 shows exactly this. --2A02:586:292B:EA0E:E08F:CE97:FFEA:E15E 06:47, 15 October 2023 (PDT)

Missing redirects

cpp/numeric/math/HUGE_VALF and cpp/numeric/math/HUGE_VALL redirect to cpp/numeric/math/HUGE_VAL. c/numeric/math/HUGE_VALF and c/numeric/math/HUGE_VALL should similarly go to c/numeric/math/HUGE_VAL.--2A02:586:292B:EA0E:30A6:F697:75DA:1AC1 11:28, 15 October 2023 (PDT)

Might as well ✔ Done --Ybab321 (talk) 13:24, 15 October 2023 (PDT)

The use of the comma operator in the example code at https://en.cppreference.com/w/Template:cpp/container/constructor is unnecessary and confusing for inexperienced c++ developers Alanbirtles (talk) 23:22, 17 October 2023 (PDT)

It's kinda funny yeah, but you gotta get that comma operator experience somewhere right? Otherwise you'll be doomed to be inexperienced forever! But yeah, it's a bit comma abusive, not against changing it to two statements --Ybab321 (talk) 02:26, 18 October 2023 (PDT)

the comma has a lot of cute semi-idiomatic uses (maybe I should list them on cpp/language/operator_other#Built-in_comma_operator - the example there is just showing what it does, but not what it's good for ).. As for this example, I think it's a good idea to keep the container printing code tight so that more of the example can be about the topic of the page. Personally I'd just space-separate them with the dangling space in the end. --Cubbi (talk) 10:37, 18 October 2023 (PDT)

"constructs an std::errc error code" is wrong. It should be "constructs an error code from a std::errc"

https://en.cppreference.com/w/cpp/error/errc In this page (and other) where we show a preview of std::make_error_code(std::errc) it says that it construct an std::errc which is incorrect. It proves that it is incorrect when you click on the link of the std::make_error_code function which then says: "Creates error code value for errc enum e".

Thank you for your work, I love this website! :)

Yeah that was not the finest wording. Fixed {done} --Ybab321 (talk) 02:28, 18 October 2023 (PDT)

Simplify example

Replace

   maybe_unused
   auto zero = [] { /* ... */ return nullptr; };
   //std::string sc{zero()}; // Before C++23: throws std::logic_error
                             // Since C++23: won't compile, see overload (12)

with

 //std::string sc(0); // Before C++23: throws std::logic_error
                      // Since C++23: won't compile, see overload (12)

(one of the reasons the overload got deleted is that 0 is treated as nullptr in this context)

Not sure what that lambda was for... Fixed ✔ Done --Ybab321 (talk) 02:37, 18 October 2023 (PDT)

Why does nth_element appear under sorting and not partitioning?

Hi

nth_element is such that 1 element is in the correct place afterwards, all elements before are <= the element, all elements after are >= element. That is not "sorting", that is partitioning.

Stephen Howe

I suspect the reason is because the algorithms were categorised similarly to how they're categorised in the standard. I think it's sufficiently appropriate personally, std::nth_element requires a sortable sequence (i.e. less than comparison admits a strict weak ordering), where the partitioning operations merely require a unary predicate, and algorithmically, the selection algorithms used for nth element are more similar to sorting algorithms than partitioning algorithms. Not that any of this really matters --Ybab321 (talk) 08:48, 18 October 2023 (PDT)

Typo in std::chrono::duration page

Under section "Helper types", "interger" should be changed to "integer". 212.15.186.9 06:54, 20 October 2023 (PDT)

Thanks. Fixed ✔ Done --Ybab321 (talk) 08:10, 20 October 2023 (PDT)

Typo on constructor for |unordered_map|

On the constructor page for |unordered_map|, under the Notes section, it currently reads:

> Although not formally required until C++23, some implementations has already put

> the template parameter Allocator into non-deduced contexts in earlier modes.

The word (above) 'has' should likely be 'had'. --Morano (talk) 11:09, 20 October 2023 (PDT)

"Have" I think. Fixed ✔ Done --Ybab321 (talk) 15:02, 20 October 2023 (PDT)

Xcode 15 libc++ supports std::expected

std::expected is supported on Xcode 15.

https://developer.apple.com/xcode/cpp/

I just updated my project to the c++23 standard and can confirm I can use std::expected with the libc++ that ships with Xcode 15.

std::expected doesn't work on clang-16 and clang-17

std::expected not available on clang-16 or clang-17

clang-16 compile failure:

https://github.com/acgetchell/CDT-plusplus/actions/runs/6621477342/job/17985496207

clang-17 compile failure:

https://github.com/acgetchell/CDT-plusplus/actions/runs/6621477365/job/17985496236

gcc-12 compile success:

https://app.travis-ci.com/github/acgetchell/CDT-plusplus/jobs/612081167

gcc-13 compile success:

https://github.com/acgetchell/CDT-plusplus/actions/runs/6621477345/job/17985496195

It also compiles successfully on macOS with libc++ included with Xcode 15.

Calling clear after istringstream::str

I think there should be some note on `https://en.cppreference.com/w/cpp/io/basic_istringstream/str` to call `istringstream::clear` after setting a new input string by `istringstream::str`. Otherwise, if you've read on the preceding string to the end, and the eof or fail bits are set, reading from the new string will fail. 2003:DC:AF3C:5600:405F:3FE8:146F:36E7 08:32, 25 October 2023 (PDT)

Hm, this is a general property of reaching the end of a stream and then reusing it. Such a note would apply to std::istream::seekg, std::ifstream::open and std::ispanstream::span, so probably worth writing a transclusion for. Tempting to just put clear() into the code examples... In any case, I agree, that would be a good note --Ybab321 (talk) 10:39, 25 October 2023 (PDT)

there's some variety here; cpp/io/basic_ifstream/open clears all flags (but remember to close before reopening), cpp/io/basic_istream/seekg clears EOF but not others. I could see a Note on cpp/io/basic_istringstream/str "unlike ifstream::open, non-const overload of str does not clear...". And I suppose a note on ifstream::open to close before reopen. --Cubbi (talk) 12:29, 25 October 2023 (PDT)

confusing use of member pointer as op

I'm having a hard time understanding which overload is used in the last call to `transform` in the example section, i.e.

ranges::transform(f, std::back_inserter(bar), &Foo::bar);

I assume it uses the second overload with `&Foo::bar` magically converted to an OP (rather than being a projection). Would it be possible to add some explanation of this conversion of a member pointer to an OP? 13.89.139.195 10:42, 26 October 2023 (PDT)

The requirements of the F op is that *result = std::invoke(op, std::invoke(proj, *first1)) works. With the identity projection, that simplifies to *result = std::invoke(op, *first1), which expands to *result = *first1 .* op. The equivalent loop would be for (const Foo& ff : f) bar.push_back(ff .* &Foo::bar);, which simplifies to for (const Foo& ff : f) bar.push_back(ff.bar); --Ybab321 (talk) 11:51, 26 October 2023 (PDT)

The intent of the example was to show how projections work (based on the comment above it), so I modified it to actually use projection instead of the obscure invokability of data member pointers --Cubbi (talk) 11:57, 26 October 2023 (PDT)

Add to pages about language features what compilers support said features

The current compiler support page albeit helpful is hard to navigate and find specific features and what compilers support them and the version of the compiler the support is offered at. I'd be extremely helpful if right before the see more section of the page there was also a table that shows compiler support for the most major compilers for the specific feature the page is about. Or in the very least a link that sends to you to the location of said feature in the compiler support page.

What you probably want is something like the "Browser compatibility table" in MDN. Unfortunately, cppreference is not backed by any compiler vendor (unlike MDN), so there is no mechanism to keep track of the compiler implementation status except manual updates by user edits. Compatility tables spreading across the site are difficult to maintain, since users need to navigate to many different pages to update the compiler implementation status.

What the pages currently have are the "Notes" sections, which contain the notable compiler incompatibilities and these feature-test macro tables (since C++20). The way recommended by the C++ standard to check whether a language/library feature is implemented is to use the feautre-test macros. --Xmcgcg (talk) 22:54, 26 October 2023 (PDT)

This can be done with a script. I've actually written one and have been using it since last year, and I think this script is good enough to help readers. See Talk:Main Page#Proposal: add User:D41D8CD98F/append-support-info.js for all users. --D41D8CD98F (talk) 23:44, 26 October 2023 (PDT)

   ... in the very least a link that sends you to the location
   of said feature in the compiler support page ...

Exactly this can be done relatively easily. Actually, this is almost what was already done with links to general FTM tables. I only need to update {{ftm}}/{{feature test macro}} templates (to deduce a proper link from known ftm and rev) and add an anchor to each row of compiler support table, based on their FTM (this means creating only one more template alike {{tta}} = Teletype Text + Anchor, etc). No need to update individual FTM-tables (spread across pages). The main work then is to update compiler support tables by filling one additional internal field per each target entry. ⇒ No interference with server cache, no javascript, no html-injection (which is great but, maybe, not all users are interested in compiler support stuff). And the maintenance would be relatively cheap w.r.t. manpower, but not as cheap as with script-solution.) --Space Mission (talk) 15:44, 27 October 2023 (PDT)

typo in fabs() page

in: https://en.cppreference.com/w/c/numeric/math/fabs

"The functions with decimal floating point parameters are declared if and only the implementation predefines" - needs to be if and only *if*.

Thanks. ✔ Done --Ybab321 (talk) 05:07, 30 October 2023 (PDT)

Wikipedia link do not work on div page due to capitalization issue

Page: https://en.cppreference.com/w/c/numeric/math/div

Link is (at the end of the page): https://en.wikipedia.org/wiki/Euclidean_Division

Link should be (observe capitalization): https://en.wikipedia.org/wiki/Euclidean_division

5.173.200.142 05:55, 30 October 2023 (PDT) Maciej Polański

Thanks ✔ Done --Ybab321 (talk) 06:25, 30 October 2023 (PDT)

std::lower_bound is broken

Returns an iterator pointing to the first element in the range [first, last) such that element >= value

78.82.103.229 09:17, 2 November 2023 (PDT)

What's broken about that? --Ybab321 (talk) 11:44, 2 November 2023 (PDT)

std::error_category::message and related are not thread-safe

Relevant pages:

• std::error_code::message
• std::error_category::message
• std::system_error because of std::system_error::what

Because these types use std::strerror internally, they are not thread-safe (this is documented on the page of std::strerror).

Here's just one implementation from GCC: [8] [9]

I think it should be documented that using these types is only appropriate in single-threaded applications!

--84.190.143.49 08:22, 3 November 2023 (PDT)

Glibc has thread-safe strerror, as does musl and newlib. We can say that libstdc++'s error_category::message is not thread-safe if used with a libc that is not well-known, but I doubt whether anyone do this in practice, and whether libstdc++ officially supports such usage. --D41D8CD98F (talk) 19:47, 3 November 2023 (PDT)

Uniform initialization of undordered_map is very confusing

#include <iostream>
#include <unordered_map>
 
int main()
{
    std::unordered_map<int,char> map = {{1,'a'},{1,'b'},{1,'d'},{2,'b'}};
    auto range = map.equal_range(1);
    for (auto it = range.first; it != range.second; ++it)
        std::cout << it->first << ' ' << it->second << '\n';
}

Here's the breakdown of your map initialization I would expect to happen:

{1, 'a'} is added. {1, 'b'} is added, overwriting the previous value associated with the key 1. {1, 'd'} is added, overwriting the previous value associated with the key 1. {2, 'b'} is added.

Documentation says 1 a is printed meaning the first key value pair is used and rest ignored. Is this documented ?

this is the equal_range example from cpp/container/unordered_map/equal_range which makes more practical sense in its cpp/container/unordered_multimap/equal_range version, but yes, as cpp/container/unordered_map/unordered_map says, what happens here is actually an open issue LWG issue 2844. We should indeed adjust the example here. --Cubbi (talk) 14:25, 3 November 2023 (PDT)