text:
Talk:Public International Law/Human Rights Law

Review: 8 June 2023
Dear Annalisa,

Thanks also from my side for this informative chapter! I left some detailed comments in the text; here some overall/borader points:

- According to the guidelines we sent around, which should ensure the coherence of the book, the chapter should start with A. Introduction, in which the field and the questions raised is introduced in more general terms. What is HR all about? I also think a clearer contextualisation within IL would also be great. The development of HR is said to have changed the very structure of IL, from a very state-centred law of cooperation to a law more focused on issues around individual rights, visible also in ICJ jurisprudence, for example (LaGrand, Avena etc.) - Given that this is the introduction to a chapter with many sub-chapters, I think it would be great if you could set a little bit more the scene for the chapters that follow, mention the questions that will be discussed and creating a narrative. For example, the role of regional HR law as well as the entire HR criticism debate could be mentioned more clearly and more centrally.

Best, Raffaela --Raffaela Kunz (discuss • contribs) 14:20, 7 June 2023 (UTC)

Review: 31 May 2023
Dear Annalisa,

Thank you for writing this concise and to the point introduction to international human rights law. It will certainly spark students' interest and curiosity and challenge them to think more deeply about human rights. Please find more detailed feedback in the comments.

With best wishes,

Sué

Sué González Hauck (discuss • contribs) 19:13, 31 May 2023 (UTC)

Review: May 25, 2023
I found your approach to be incredibly engaging and thought-provoking. The narrative you crafted, which explores the (post-)modern history of human rights through recent historical events, provides students with a profound understanding of the intricate relationship between human rights and history. One aspect that truly stood out to me was your departure from the conventional style often found in established textbooks. By adopting a unique and refreshing approach, you have managed to captivate students.

However, I would like to offer a small word of caution regarding the level of assumptions made in certain sections of your chapter. As an introductory chapter on human rights, it is crucial to ensure that students with varying levels of familiarity with the subject can grasp the core concepts. While your innovative approach is admirable, it might be beneficial to provide additional context or explanations for some of the ideas you present.

Furthermore, you have very few footnotes. If you would like assistance in transferring the footnotes from your Word document to Wikibooks, please feel free to send me the document, and I will be more than happy to help you with the process.

You will also find some comments in your chapter in which I elaborate on something more specific. To view these comments, open your chapter page and click "Edit" in the top-right menu bar.

Some minor things:
 * Please use OSCOLA as your citation style and make sure you provide full and accurate references for all sources cited. It is important to take the time to ensure that all footnotes are correctly formatted according to OSCOLA.
 * You could add some links to other chapters of the textbook.
 * Note that I have made some linguistic improvements to the text

--Max Milas (discuss • contribs) 13:55, 25 May 2023 (UTC)

Review: Deepa
The chapter covers the evolution of the international human rights system. Under some of the chapter sub-headings, a few other notable developments can be incorporated. In case the following points have been added or do not fit into the design of the chapter, kindly ignore them.

1. The failure of the "unity design" can also be seen in the light of Article 29 of the UDHR on duties. To make up for this failure, "duty-based" international resolutions have emerged as separate from the human rights treaties.

2. The point on the isolation of "third-generation" or group rights under the ICCPR and other treaties is kind of debatable. ICCPR and the others contain a provision on self-determination, trade union, peaceful assembly, etc.

3. On NGOs (international and national), their emergence or identity in international/ human rights law can be traced to the recognition of their Consultative Status by the UN.

4. The Convention on Elimination of All Forms of Racial Discrimination, 1965 can also be viewed as a major contributor to the international decolonization project.

5. The sub-theme on "divide between theory and practice" is the most fascinating part of the chapter. The author may also consider the third-world voices which came through the Bangkok Decl. etc to respond to the appearing divide. In addition, the acts of genocide, war crimes, etc. led to the creation of the ICC (Rome Statute) and the R2P (2005 Document)to mark a major evolutionary leap in international/human rights law. In addition, the question of whether international financial institutions like IMF, World Bank, etc. have human rights accountability also represents this divide.

6. On the membership of treaties, the more recent ones i.e. Migrant Workers Convention and Convention on Enforced Disapperances suffer from the membership/ratification challenge with very few states signing up.

7. On the effectiveness of the international human rights system, the author may also consider discussing the adoption of Optional Protocols to Human Rights Treaties, which bring in processes/mechanisms for investigation (Torture Conv.), Enquiry, Complaints/Communications Mechanisms, etc. Further, the 1991 Paris Principles laid the foundation for the setting up of National Human Rights Institutions. In addition, the "economic" and "technology" based agendas have been addressed by the treaty bodies within existing provisions. They have covered taxation, corruption, good governance, climate change, use of surveillance technologies, technology, law enforcement, etc.

8. The 1986 Declaration on Development introduced the language for a new international order based on human rights principles. Interestingly, a binding treaty on the right to development is in the pipeline.

9. Several soft-law instruments have been influential, particularly on human rights defenders, victims of crimes, Ruggie's Framework on Business and Human Rights, Yogykarta Principles, etc.

--Deepa Kansra (discuss • contribs) 05:04, 19 February 2022 (UTC)


text:
C++ Language/Preprocessing/PreprocessingStrings

Two adjacent string literals are treated as if they had been concatenated.

For a string literal that contains a special character (e.g., a newline), either escape that special character or use a raw-string-literal.

A preprocessor macro can optionally add quotation marks to a macro-parameter while that macro expands.

Additional information about preprocessing strings (includes interactive examples)

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
C++ Language/Preprocessing/CompileTimeConstants

In C++ syntax, there are some quantities that must be known while your compiler is compiling. In those situations, you could use expression  (because the compiler is able to perform arithmetic while it's compiling), but function calling is too complex of an activity to occur during compilation (unless that function's features are radically stripped-down). Use keyword  to mark a stripped-down function that might be "called" during compilation, or a variable which might be "evaluated" during compilation.

Additional information about compile-time constants (includes interactive examples)


text:
C++ Language/Preprocessing/CompileTimeAssertions

The traditional way to assert the truth of something at compile-time was to use the preprocessor's  (within some   block). But some compile-time activity happens after the preprocessor has finished, so modern code uses a  compile-time assertion.

Additional information about compile-time assertions (includes interactive examples)


text:
C++ Language/Preprocessing/ConditionalCompilation

The traditional way to conditionally-compile code was to use  or. But the preprocessor cannot reason about types, so modern code sometimes uses  instead.

Additional information about conditional-compilation (includes interactive examples)


text:
C++ Language/Namespace/NamespaceShortcuts

Anything defined with  will require additional qualification (writing variable   as  ) unless you have requested to skip that requirement on a case-by-case basis (programming  ).

Or, the qualification requirement could be skipped for an entire namespace all at once.

Additional information about namespace shortcuts (includes interactive examples)


text:
C++ Language/Namespace/Nesting

Namespaces can be nested, with the qualification programmed as.

Additional information about nesting namespaces

title: C++ Language/Namespace/Nesting


text:
C++ Language/Namespace/SplittingAcrossFiles

A single namespace's location can be split, possibly across multiple files.

Additional information about splitting a namespace across files


text:
C++ Language/Namespace/NamedAndUnnamed

An unnamed  is a way to restrict the visibility of a global variable to one single file.

If you dislike the name that somebody gave to a namespace,  creates your own alias for it.

Additional information about unnamed namespaces (includes interactive examples)

title: C++ Language/Namespace/NamedAndUnnamed


text:
C++ Language/Type

In C++, every variable is required to have a well-defined "type", which describes how its values are represented in memory (and what operations are appropriate for those values).

 * 1) Hungarian Prefixes
 * 2) Boolean
 * 3) Literals
 * 4) Bitwise Representation
 * 5) Max Value
 * 6) Conversion
 * 7) Enumeration
 * 8) Shortcuts
 * 9) Variant
 * 10) RTTI: RunTime Type Information

title: C++ Language/Type


text:
C++ Language/Type/HungarianPrefixes

C++'s signed integer types are,  ,  , and. On Win32, the sizes of those are 1, 2, 4, and 8 bytes (respectively), but that might be different on other platforms. Each of those types has an unsigned version (e.g.,  instead of  ).

C++'s floating-point types are  and. On Win32, the sizes of those are 4 and 8 bytes (respectively).

A popular programming practice is to name your variables using a "Hungarian prefix", where its name's first few letters is an encoding of that type (e.g., variable  has type  ), but the language makes no such requirement.

Additional information about Hungarian prefixes (includes interactive examples)

title: C++ Language/Type/HungarianPrefixes


text:
C++ Language/Type/Boolean

C++'s primitive boolean type is. It has values  and.

Additional information about booleans

title: C++ Language/Type/Boolean


text:
C++ Language/Type/Literals

A "literal" is a portion of source code that literally states some value. For example, one possible literal expression of the  type would be.

 * 1) Financial 1000-Markers
 * 2) Binary and Hexadecimal
 * 3) Custom Literals

title: C++ Language/Type/Literals


text:
C++ Language/Type/Literals/FinancialThousandMarkers

A number like one million cannot be programmed as  because the comma is used for other purposes. But you can write a numeric literal as.

Additional information about 1000-markers (includes interactive examples)


text:
C++ Language/Type/Literals/BinaryAndHexadecimal

The number thirteen can be written in decimal, hexadecimal , octal , or binary.

Additional information about binary and hex literals (includes interactive examples)


text:
Category:Book:Web applications in React, Bootstrap, MongoDB, Express

Web applications in React, Bootstrap, MongoDB, Express,


text:
User:Xitekateka

Evaluate

title: User:Xitekateka


text:
User talk:Xitekateka

life goes on

You left me on the zone all alone .Now I'm in the dim thinking about the memories that we had.

I'm grateful we had peace. My brother how long must we groan .Now I know that things will never be the same.

We used to call the house a home, but a house isn't a home when your loved ones are gone.

It is still the same world nothing has changed. I wish I can take the pain away ,

You'll always be in my heart, I remember those days we used to play casino at the befront veranda.

I promise I'll make you proud. may your psyche find a better place to repose in peace

English
Staying real Xitekateka (discuss • contribs) 07:19, 19 February 2022 (UTC)

title: User talk:Xitekateka


text:
Annotated King Reference Manual/Types

This page is work in progress.

Type Declarations
Some general principles:

 * All scalar subtypes have a default value. For bounded numeric and enumeration subtypes, this is the 'First of the subtype, unless a different value is specified with the Default_Value aspect. For unbounded numeric subtypes, the Default_Value aspect must be specified. Note that an unbounded numeric type can have bounded subtypes.
 * The Predicate aspect may be specified for all subtypes.
 * All scalar types have the attributes 'Image, 'Value, 'Min, 'Max, 'Previous, and 'Next.
 * Integer and enumeration types have the attributes 'Position, 'Value (integer), 'Representation, and 'From_Representation. For integer types, 'Position and 'Representation both give the value of the parameter, and 'Value (integer) and 'From_Representation give the value of the type with the value of the parameter (if that exists); this is similar to 'Pos and "Val for integer types in Ada.
 * 'Image <=>, 'Value (string) are inverses of each other, as are 'Position <=> 'Value (integer)

Syntax
type_declaration ::= full_type_declaration | hidden_type_declaration full_type_declaration ::= type defining_identifier [known_discriminant_part] is type_definition [aspect_specification]; hidden_type_declaration ::= type defining_identifier [discriminant_part] is hidden [aspect_specification]; discriminant_part ::= unknown_discriminant_part | known_discriminant_part unknown_discriminant_part ::= (<>) known_discriminant_part ::= (discriminant_specification {; discriminant_specification}) discriminant_specification ::= defining_identifier : subtype_mark [<- default_expression] type_definition ::= enumeration_type_definition | integer_type_definition | real_type_definition | map_type_definition | sequence_type_definition | set_type_definition | record_type_definition | derived_type_definition | module_type_definition | task_type_definition

Rationale
-

Discussion
-

Syntax
enumeration_type_definition ::= (enumeration_literal_specification {, enumeration_literal_specification}) enumeration_literal_specification ::= defining_identifier | defining_character_literal

Rationale
-

Discussion
-

Syntax
integer_type_definition ::= bounded_integer_type_definition | unbounded_integer_type_definition bounded_integer_type_definition ::= range static_simple_expression .. static_simple_expression unbounded_integer_type_definition ::= range <>

Rationale
Bit-wise operations are available for the base type of all bounded integer types that fit in a single hardware integer.

Discussion
-

Syntax
real_type_definition ::= floating_point_definition | fixed_point_definition

Syntax
floating_point_definition ::= bounded_floating_point_definition | unbounded_floating_point_definition bounded_floating_point_definition ::= digits static_expression [real_range_specification] real_range_specification ::= range static_simple_expression .. static_simple_expression unbounded_floating_point_definition ::= digits <>

Rationale
-

Discussion
-

Syntax
fixed_point_definition ::= bounded_fixed_point_definition | unbounded_fixed_point_definition bounded_fixed_point_definition ::= delta static_expression real_range_specification unbounded_fixed_point_definition ::= delta static_expression range <>

Rationale
Shouldn't decimal types be available, in order to cover the corresponding available type of Ada?

A King fixed-point type with a delta that is a power of 10 is equivalent to an Ada decimal fixed-point type.

type Money is delta 0.01 digits 14;

The above would be equivalent to:

type Money is delta 0.01 range -999_999_999_999.99 .. 999_999_999_999.99;

Discussion
-

Syntax
map_type_definition := map key_subtype_mark => value_subtype_mark

Operators
"=" is only defined if it is defined for the value subtype.

Attributes
-

Aspects
-

Rationale
Maps may also be implemented by functions, so King uses a common notation for both.

Discussion
-

Syntax
sequence_type_definition := sequence of element_subtype_mark

Operators
"=" is only defined if it is defined for the value subtype.

Attributes
-

Aspects
-

Rationale
-

Discussion
-

Syntax
set_type_definition := set of element_subtype_mark

Attributes
-

Aspects
-

Component deference
-

Rationale
-

Discussion
-

Syntax
record_type_definition ::= record_definition record_definition ::= record component_list end record record_identifier component_list ::= component_item {component_item} | {component_item} variant_part | null; component_item ::= component_declaration component_declaration ::= defining_identifier : component_definition [<- default_expression] [aspect_specification]; component_definition ::= subtype_indication variant_part ::= case discriminant_direct_name is variant {variant} end case; variant ::= when discrete_choice_list => component_list discrete_choice_list ::= discrete_choice {| discrete_choice} discrete_choice ::= choice_expression | discrete_subtype_indication | range_specification | others

Attributes
-

Aspects
-

Rationale
-

Discussion
-

Syntax
derived_type_definition ::= new parent_subtype_indication

Operators
-

Attributes
-

Aspects
-

Rationale
The operations, attributes, and so on are based on the parent type.

Discussion
-

Syntax
module_type_definition ::= module subprogram_declaration {subprogram_declaration} end module module_identifier

Operators
-

Attributes
-

Aspects
-

Rationale
-

Discussion
-

Syntax
task_type_definition ::= task

Attributes
-

Aspects
-

Rationale
-

Discussion
-

Syntax
task_type_definition ::= task subprogram_declaration {subprogram_declaration} end task task_identifier

Attributes
-

Aspects
-

Rationale
Passive tasks are the only way that active tasks may communicate.

Discussion
-

title: Annotated King Reference Manual/Types


text:
Tyap/Tyiet 1/Lesson 1 (Salutations)

 * 1. A kwai doot ka̱ngka̱ra̱ng a? = Good morning! (to one person)
 * Nyi kwai doot ka̱ngka̱ra̱ng a? = Good morning! (to more than one person)
 * 2. A shyip ka̱ngka̱ra̱ng a? = Good morning! (to one person)
 * Nyi shyip ka̱ngka̱ra̱ng a? = Good morning! (to more than one person)
 * Nyi shyip ka̱ngka̱ra̱ng a? = Good morning! (to more than one person)

 * A kwamam ka̱ngka̱ra̱ng a? = Good day/afternoon/evening! (to one person)
 * Nyi kwamam ka̱ngka̱ra̱ng a? = Good day/afternoon/evening! (to more than one person)
 * Nyi kwamam ka̱ngka̱ra̱ng a? = Good day/afternoon/evening! (to more than one person)

 * Si̱ a̱tson ka! = Good night!
 * A̱gwaza gu ta̱ngam nzi̱t ka̱ngka̱ra̱ng! = Good night!
 * A̱gwaza gu ta̱ngam nzi̱t ka̱ngka̱ra̱ng! = Good night!

<>

title: Tyap/Tyiet 1/Lesson 1 (Salutations)


text: XHTML/Printable version

title: XHTML/Printable version


text:
Cookbook:Snap Pea

The snap pea, or sugar snap pea, is a type of edible pod pea. The snap pea is distinguished from the similar snow pea by its thickness and rounded shape.

title: Cookbook:Snap Pea


text: BASIC Programming/Printable version

title: BASIC Programming/Printable version


text:
Cookbook:Saltine Cracker

Saltine crackers, or soda crackers, are a type of simple, crisp cracker. They are available under various brand names, and they may be eaten on their own or used as a component in other recipes.

Saltine Cracker Recipes

 * Stuffed Portabella Mushrooms
 * Potatoes in Cream Sauce of Huancayo (Papas a la Huancaína)
 * Chicken Mull
 * Pineapple Side Dish

title: Cookbook:Saltine Cracker


text:
User:Nemo0110

Computer Science

 * Computer Science Design Patterns

title: User:Nemo0110


text:
Making Websites with Flask/Templating

What is templating?
When we are making Flask apps, we often want to return an HTML file, not just a string of HTML. Using templating, we can do this, along with many more advanced things like variables, loops, base templates, and more.

Making a Template File
To make a template file, we make an HTML file in a folder called. For example, let's make called our HTML file  and put the following in it:

Displaying Templates
To display a template, we use the  function. To use it, we first of all need to import it from the Flask module: Then, we use the   function when we are returning our functions. We pass in the name of the template HTML file into the  function. So, something like the following:

Inline Code Storing
Another way you can serve HTML code is by serving it inline. Here is a example: In this example, instead of the HTML being loaded from an external file, it is being directly given to the user.

Test it out
On your Python editor, run the program. Then open a browser. Navigate to http://127.0.0.1:5000/ and you should see a web page congratulating you. If you don't, check the console to debug.

title: Making Websites with Flask/Templating


text:
User talk:ChanWasonasong

Blocked
You cannot edit for 1 month due to harassment. You are welcome to contribute constructively when editing privileges are restored. You may appeal this action with a reasonable argument by adding the text below.

title: User talk:ChanWasonasong


text:
C++ Language/Type/Literals/CustomLiterals

You can now define your own custom syntax for literals of the form. After programming, you can use   in any situation where you used to program with an ordinary numeral.

Additional information about custom literals (includes interactive examples)


text:
C++ Language/Type/BitwiseRepresentation

A numeric type like  is stored in computer memory as a well-defined sequence of "bits" (each having a value of 0 or 1).

 * 1) Ordering of Bytes
 * 2) Negative Value
 * 3) Bit Shifting
 * 4) Non-char Byte
 * 5) Bit Flags

title: C++ Language/Type/BitwiseRepresentation


text:
C++ Language/Type/BitwiseRepresentation/OrderingOfBytes

All CPUs are either "little-endian" (the least-significant bytes occur first in the internal representation of an integer) or "big-endian" (the opposite order).

Additional information about the ordering of bytes


text:
C++ Language/Type/BitwiseRepresentation/NegativeValue

The negative value of an integer could be stored as either "2's complement" (-1 viewed as  is  ) or "1's complement" (it is  ).

Additional information about representing a negative value (includes interactive examples)


text:
C++ Language/Type/BitwiseRepresentation/BitShifting

A value's bits could be shifted leftwards or rightwards with  or   operators.

Additional information about bit shifting (includes interactive examples)


text:
C++ Language/Type/BitwiseRepresentation/NonCharByte

A  variable is like a   variable, except that it can only be used for bitwise operations (not for character nor numeric operations).

Additional information about the non-char byte type (includes interactive examples)


text:
C++ Language/Type/BitwiseRepresentation/BitFlags

A variable whose type is  stores five bits (five flags), which are individually accessed using array-indexing notation.

Additional information about bit flags (includes interactive examples)


text:
C++ Language/Type/MaxValue

Because an integer type is defined using a finite number of bits, there is a limit to how big of a number could be represented.

 * 1) Overflow
 * 2) INT_MAX

title: C++ Language/Type/MaxValue


text:
C++ Language/Type/MaxValue/Overflow

On Win32, the max value that can be stored in a  variable is. If you further increment that variable, it will "overflow" (wrapping around back to  without error or warning).

Additional information about overflow (includes interactive examples)

title: C++ Language/Type/MaxValue/Overflow


text:
C++ Language/Type/MaxValue/Intmax

In C, macros like  and   had been defined to be the smallest and largest values that could be represented in that particular type.

C++'s modernization of  is.

Additional information about INT_MAX

title: C++ Language/Type/MaxValue/Intmax


text:
C++ Language/Type/Conversion

If you have a variable of one type, but need to use it in a situation that expects a different type, then you can perform a type conversion.

 * 1) Promoting Small Integers
 * 2) Coercion
 * 3) Casting

title: C++ Language/Type/Conversion


text:
C++ Language/Type/Conversion/PromotingSmallIntegers

Often, there are no machine-language mathematical operators for integers smaller than. Consequently, the compilation result of  where   and   are both   will "promote" both of these two terms into   before doing the addition.

Additional information about integer promotion (includes interactive examples)


text:
C++ Language/Type/Conversion/Coercion

A math operation can only be applied to two operands of the same type. If they are not already of the same type, then one of them will need to be "coerced" (if possible, the compiler automatically inserts an implicit type-conversion that changes a value's representation from one type to another).

Additional information about coercion (includes interactive examples)

title: C++ Language/Type/Conversion/Coercion


text:
C++ Language/Type/Conversion/Casting

A "type cast" is a manually-programmed expression of type-conversion.

Traditional C programs wrote casting as.

C++ programs write casting as.

When casting from a pointer-to-base-class into a pointer-to-derived-class, using  instead of   adds a runtime check which returns   if the pointed-at object wasn't actually an instance of that derived class.

Additional information about casting (includes interactive examples)

title: C++ Language/Type/Conversion/Casting


text:
C++ Language/Type/Enumeration

A traditional enumeration was written as, but modern code writes it as. In the modern way, values must be fully-qualified as  when they are used.

Additional information about enumeration (includes interactive examples)

title: C++ Language/Type/Enumeration


text:
C++ Language/Type/Shortcuts

The traditional way of defining a C++ variable explicitly specifies a type and a variable name. But several language features allow a programmer to take a shortcut, instead of fully specifying a type and a variable name.

 * 1) Templated typedef
 * 2) From Another Variable
 * 3) From Initialization
 * 4) From a return Statement
 * 5) Trailing Return Type

title: C++ Language/Type/Shortcuts


text:
C++ Language/Type/Shortcuts/TemplatedTypedef

A "type alias" lets you use a new name for an existing type.

Traditionally, this was programmed as.

In modern C++, this is programmed as. Only the modern syntax can be templated.

Additional information about type aliases (includes interactive examples)


text:
C++ Language/Type/Shortcuts/FromAnotherVariable

If variable  has already been defined to have type , then definition   is the same as defining. This  shortcut can even refer to a full expression.

Additional information about decltype (includes interactive examples)


text:
C++ Language/Type/Shortcuts/FromInitialization

The compiler can infer a variable's type from its initialization data. So defining  is the same as defining   (because   is a   literal).

Additional information about inferring type from initialization data (includes interactive examples)


text:
C++ Language/Type/Shortcuts/FromReturnStatement

A compiler can infer a function's return type from its  statement, by specifying the return type as either   or.

Additional information about inferring type from a return statement


text:
C++ Language/Type/Shortcuts/TrailingReturnType

In templated code (using template-parameter ), if you want your compiler to infer a function's return type from an expression that involves a parameter's type, then use this "trailing return type" syntax:.

Additional information about the trailing return syntax


text:
C++ Language/Type/Variant

Variants (any-variants, templated-variants, and optional-values) are sometimes collectively called "the new vocabulary types".

 * 1) Any-Variant
 * 2) Templated-Variant
 * 3) Optional-Value

title: C++ Language/Type/Variant


text:
C++ Language/Type/Variant/AnyVariant

A variable  whose type is   can store values of differing types at different points in time. After assigning, that   value can be accessed by. An uninitialized any-variable will be in a special "no value" state that will be reported by.

Additional information about any-variant (includes interactive examples)

title: C++ Language/Type/Variant/AnyVariant


text:
C++ Language/Type/Variant/TemplatedVariant

A variable  whose type is   can store a value that is either   or   or   (only one of those options at a time). Thus, this templated-variant variable is a modern alternative to a C. After assigning, you know that the variable is currently storing a   because   returns   and   returns   (0-based indexing of type options). Access that value by either  or by.

Additional information about templated-variant (includes interactive examples)


text:
C++ Language/Type/Variant/OptionalValue

A variable whose type is  is similar to a pointer to   in the sense that its value might be   (similar to a null pointer). In that case, we understand it to semantically mean that the variable "has no meaningful value". Otherwise, an  can be stored by assignment, and accessed by dereferencing.

Additional information about optional-value (includes interactive examples)

title: C++ Language/Type/Variant/OptionalValue


text:
C++ Language/Type/Rtti

The C++ standard provides rather little support for RTTI. You can call, which returns a   that can be equated (using  ) or converted into string (using  ).

Additional information about RTTI

title: C++ Language/Type/Rtti


text:
C++ Language/Variables

A variable is a name given to a piece of computer memory, in which you can store a value of a certain type.

 * 1) Lifetime and Scope
 * 2) Initialization
 * 3) Uniform Initialization
 * 4) Initialize without Constructor
 * 5) Decomposing-Auto
 * 6) Define at Same Time as Type

title: C++ Language/Variables


text:
C++ Language/Variables/LifetimeAndScope

A variable defined outside of all functions will have "static-lifetime" (it will exist throughout your software's entire duration). A variable defined inside some function could also have static-lifetime, but it would need to be marked by the  keyword. Otherwise, it would be a transient "local-variable" whose storage will disappear when that function ends.

A variable defined inside some function has "local-scope" (it can only be used from within that function, regardless of its lifetime). A variable defined outside of all functions has "global-scope" (it can be used by all subsequent functions). If you mark a globally-scoped variable by the  keyword, then it can only be used in this source file.

Additional information about lifetime and scope

title: C++ Language/Variables/LifetimeAndScope


text:
C++ Language/Variables/Initialization

A constant variable (marked by the  keyword) must be initialized. If a static-lifetime variable is not manually initialized, then it will be automatically initialized to 0. If a local object variable is not manually initialized, then its default-constructor will construct it. If a local primitive variable is not manually initialized, then its value will be undefined until something gets assigned to it.

Additional information about initialization (includes interactive examples)

title: C++ Language/Variables/Initialization


text:
C++ Language/Variables/UniformInitialization

There are three different syntax that you could use for initializing a variable: traditional "implicit initialization", traditional "explicit initialization" , and modern "uniform initialization".

Additional information about uniform initialization (includes interactive examples)


text:
C++ Language/Variables/InitializeWithoutConstructor

Traditionally, data members were initialized by passing parameters to a custom constructor, which would copy those parameterized values to the data members.

In modern C++, you also have the option of just using the default constructor, and specifying those values as an initialization list. The items from that brace-enclosed list will be given to data members based on the order of members within the class definition.

Additional information about initializing without a constructor (includes interactive examples)


text:
C++ Language/Variables/DecomposingAuto

The statement  simultaneously defines two variables (  and  ), initializing each of them to some corresponding value from the right-hand-side. The right-hand-side could be a  or it could be an object (whose first data member is a , and second data member is a  ).

Additional information about decomposing-auto (includes interactive examples)

title: C++ Language/Variables/DecomposingAuto


text:
C++ Language/Variables/DefineAtSameTimeAsType

Programmers usually define a class separately from using that class' name in an object's definition (a subsequent   statement). However, it is possible to combine these into a single codeline.

Additional information about defining a variable at the same time as a type


text:
C++ Language/Indirection

Instead of directly referring to a piece of computer memory by the name of some variable, C++ software sometimes refers to it in a more indirect way.

A "pointer" is a variable whose value is a memory address. If  has already been defined as a   variable, defining   will use the "address-of" operator  to obtain the address where   has been stored in memory — that memory address will get stored in pointer variable.

On the other hand, a "reference" doesn't create any additional storage; instead, it specifies a new name  which now also refers to that same storage location that already existed for.

 * 1) Pointers
 * 2) Typed NULL
 * 3) Arrays
 * 4) Reference Variables
 * 5) Rvalue-References
 * 6) Smart Pointers

title: C++ Language/Indirection


text:
C++ Language/Indirection/Pointers

Evaluating the name of a pointer variable produces a memory address. Evaluating the "dereferencing" of that pointer variable produces whatever value had been stored in memory at that memory address.

Additional information about pointers

title: C++ Language/Indirection/Pointers


text:
C++ Language/Indirection/TypedNull

The traditional  macro was really just a   with value. This is commonly used as a special value assigned to a pointer variable, having the semantic meaning of "not pointing at anything" (because computers will never try to use their memory at address 0).

Modern C++ uses  instead of , because   has a dedicated   type.

Additional information about nullptr

title: C++ Language/Indirection/TypedNull


text:
C++ Language/Indirection/Arrays

The definition  defines an "array" variable. In memory, space is reserved for three integers (contiguously). The array variable  is equivalent to a pointer which is pointing at the first of those three integers.

Additional information about arrays (includes interactive examples)

title: C++ Language/Indirection/Arrays


text:
C++ Language/Indirection/ReferenceVariables

A reference must always be initialized to some kind of existing storage, and the location of that storage cannot be changed. However, the value stored at that location can be changed, so subsequently doing  will cause   to now contain.

Additional information about reference variables (includes interactive examples)


text:
C++ Language/Indirection/RvalueReferences

Traditional C++ considered the datatype  to be a "reference to  ".

Modern C++ refines that, so  is now more precisely a "lvalue-reference to  ". That is distinguished from, which is a "rvalue-reference to  ".

 * 1) Move-Semantics
 * 2) Moving from this
 * 3) Perfect Forwarding


text:
C++ Language/Indirection/RvalueReferences/MoveSemantics

Traditionally, a class could provide a "copy-constructor"  and a "copy-assignment operator". These would get used in several situations, such as the definition of  by   (where   had already been defined as a   object). If  is some kind of custom container, then these two functions are usually implemented by deeply copying all contained items, which might be computationally-expensive.

In modern software, these are supplemented by also programming "move-constructor" and "move-assignment operator" functions that are implemented by only transferring a payload handle. Function overloading can distinguish between move-constructor and copy-constructor, because the move-constructor parameter's type is a "rvalue-reference".

Additional information about move-semantics (includes interactive examples)


text:
C++ Language/Indirection/RvalueReferences/MovingFromThis

A function like  is the opposite of a common assignment operator (assigning from this object to the parameter, instead of from the parameter to this object). To specify function overloading that distinguishes between move-semantics and copy-semantics, a function like  would program either   or   immediately before the function body's opening curly-brace.

Additional information about move semantics when you move from the this pointer (includes interactive examples)


text:
C++ Language/Indirection/RvalueReferences/PerfectForwarding

If both move-semantics and copy-semantics exist in both a base class and a derived class, then you might need to maintain the choice of move-or-copy when a derived class' function delegates up to the base class' function. To maintain that move-or-copy choice,  is used.

Additional information about perfect forwarding (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers

A "smart pointer" is an object which manages an allocation of memory, so that memory gets deallocated at the appropriate time.

 * 1) Risk from Raw Pointers
 * 2) Unique Ownership
 * 3) Shared Ownership
 * 4) Ownership Cycle
 * 5) Owning an Array
 * 6) Pointer to Base-Class
 * 7) Returning this
 * 8) Smart Compiler-Temporary
 * 9) Custom Destruction
 * 10) Template-Parameter

title: C++ Language/Indirection/SmartPointers


text:
C++ Language/Indirection/SmartPointers/RiskFromRawPointers

When implementing one of your functions, you might want to dynamically allocate memory (using ) which you intend to deallocate at the end of your function (using  ). But this will leak memory if an unhandled exception gets thrown during the middle of your function.

Instead of your local variable's type being a raw pointer, it could be a local object variable (initialized as ). Whenever  goes out of scope (even if because of an exception), that local object's destructor will get called. So we can move the responsibility of doing  from our manually-programmed function, into the destructor of this   "smart pointer" class.

C++ provides several built-in smart pointer classes that work like this.

Additional information about the risk from using a raw pointer


text:
User talk:SoftwareEngineerMoose

Welcome!
Welcome to Wikibooks, SoftwareEngineerMoose!

 First steps tutorial Wikibooks is for collaborative development of free textbooks.

You do not need technical skills to contribute. You can easily change most books. Please introduce yourself, and let us know what interests you.

If you already contribute at other Wikimedia projects, our Wikimedia Orientation should quickly get you started. (Would you like to provide feedback on this message?)

  Getting help   Made a mistake?   Goodies, tips and tricks
 * Read the Using Wikibooks book for a friendly introduction to the project, or our help pages for more information.
 * You can get friendly help from the community in the user assistance room or our IRC channel.
 * Upload freely licensed files to Wikimedia Commons. You may request permission to upload fair use files locally. Please include author and source information and a non-free use rationale for non-free files.
 * You can restore a previously saved version.
 * Pages should follow the  naming convention.
 * Need to rename a page? Use the move tab (is available once your account is 4 days old - until then, ask for help).
 * To request a page be deleted, add to the top of the page.
 * Was a page you made deleted? Please read the deletion policy, and check the deletion log to find out why. Also check the RFD archives if applicable. You can request undeletion at WB:RFU, or ask the administrator who deleted the page.
 * Please fill in the edit summary and preview your edits before saving.
 * Sign your name on discussion pages by typing ~~~~
 * User scripts can make many tasks easier. Look at the Gadgets tab of my preferences; check off the boxes for the scripts you want, and hit save!

Thanks for your contributions -- Jules (Mrjulesd) 08:04, 20 February 2022 (UTC)

title: User talk:SoftwareEngineerMoose


text:
C++ Language/Indirection/SmartPointers/UniqueOwnership

If a smart pointer's memory should be "owned" by exactly one client, use  for the smart pointer type.

Additional information about unique_ptr (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/SharedOwnership

Multiple  variables can collectively manage a shared memory allocation, due to built-in reference-counting. C++ will automatically call  on the underlying memory once all of the smart pointer variables have released their shared-ownership of it.

Additional information about shared_ptr (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/OwnershipCycle

The  type is for situations where you need access to the shared memory payload that is being collectively managed by several , but you don't want this   to affect the reference count. A cyclic data structure is one example where that is needed.

Additional information about weak_ptr (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/OwningAnArray

A smart pointer can own an array (e.g., ). When the time comes, it will use the correct destructor.

Additional information about smart pointers owning an array (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/PointerToBaseClass

The pointer-type managed by a smart pointer can be a base class of the actual memory allocation (i.e., ).

Additional information about using smart pointers in a class hierarchy (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/ReturningThis

Traditional C++ code might sometimes have wanted to do  (returning a   raw pointer).

To instead return, derive your class from   (so that an internal   will start owning this object), and return   instead of.

Additional information about returning the this pointer as a smart pointer (includes interactive examples)


text:
Cookbook:Chipotle Pepper

The chipotle pepper is a smoked and dried ripe jalapeño pepper.  It can come in different forms for use in cooking.

Characteristics
All chipotles are wrinkled and have a smoky, medium spicy flavor with a hint of fruity sweetness. Two primary varieties of chipotle exist: morita and meco. Moritas are dark red with a pliable texture similar to that of a raisin. They are not smoked as long, which gives them a milder flavor. On the other hand, mecos are smoked for much longer, which turns them brown and gives them an intensity of flavor. Once dried, chipotles may be processed in a few ways. They can be sold whole or ground to flakes or powder. They may also be be stewed in adobo sauce—a blend of tomato, vinegar, and spices—and canned to make a versatile condiment. When rehydrated, they can be blended to make a chipotle purée.

Selection and storage
As a dried food, chipotles keep well at room temperature when kept away from light, heat, air, and moisture. Under ideal conditions, they can last for a couple years. Canned chiles in adobo can last for days to weeks in the fridge after opening.

Preparation
Before using chipotles, remove the stems, and discard the seeds if desired to reduce the bitterness of the chile. If you want to add additional char and flavor, you can dry toast them in a skillet before proceeding. From here, you can grind or rehydrate them. To rehydrate, cut a little slit in the sides and soak in hot water—or another liquid—for several minutes.

Use
Chipotles are commonly used in Mexican cuisine, as well as Tex-Mex and United States cuisines. The ground powder makes a good component of a meat rub. Chipotles in adobo are excellent as part of condiments and marinades, where the adobo adds a tang and the chile adds spice and smoke.

title: Cookbook:Chipotle Pepper


text:
Issues in Interdisciplinarity 2020-21/Printable version

=Evidence in Racial Inequality in the US Education System=

=Evidence in the fight against anti-vaccine movements=

=Evidence in "The Resource Curse" and democratic instability in Africa=

=Evidence in the Research and Diagnosis of Depression=

=Evidence in Mindfulness and personal development=

=Evidence in Video Games being a factor of Adolescent Violence=

=Evidence in the Propagation of Digital Fake News=

=Evidence in Tariffs=

=Evidence in the Production and Consumption of the Palm Oil Boom=

=Evidence in Measuring Workplace Happiness=

=Evidence in the Plastic Continent=

=Evidence in the World Happiness Report=

=Evidence in the Development and Diagnosis of Anxiety Disorders=

=Evidence in The Plastic Continent=

=Evidence in Transgenderism=

=Evidence in Intelligence Testing=

=Evidence in Hormonal Contraception=

=Evidence in Effectiveness of Lockdown=

=Evidence in the Euthanasia of Dementia Patients=

=Evidence in the French Security Law=

=Evidence in the Medicinal usage of Cannabis=

=Truth in "The Crown"=

=Truth in censorship of women's bodies on social media=

=Truth in the definition of Gender=

=Truth in 21st century advertising=

=Truth in Euthanasia in the Netherlands=

=Truth in Virginity= {{:{{BOOKNAME}}/Truth in virginity]] =Truth in Punishment and The Panopticon= {{:{{BOOKNAME}}/Truth in Punishment and The Panopticon}} =Truth in Body Image= {{:{{BOOKNAME}}/Truth in Body Image}} =Truth in Pain= {{:{{BOOKNAME}}/Truth in Pain}} =Truth in Greenwashing= {{:{{BOOKNAME}}/Truth in Greenwashing}} =Truth in Explanations for the Rise of Human Monogamy= {{:{{BOOKNAME}}/Truth in Explanations for the Rise of Human Monogamy}} =Truth in Conspiracy Theories: Flat Earth= {{:{{BOOKNAME}}/Truth in Conspiracy Theories: Flat Earth}} =Truth in Free Will= {{:{{BOOKNAME}}/Truth in Free Will}} =Truth in COVID-19 Vaccine Distribution= {{:{{BOOKNAME}}/Truth in Distributing COVID-19 Vaccines}} =Truth in Biological Definitions of Race and Implications in Black Maternal Care= {{:{{BOOKNAME}}/Truth in Biological Definitions of Race and Implications in Black Maternal Care}} =Truth in the Stanford Prison Experiment= {{:{{BOOKNAME}}/Truth in the Stanford Prison Experiment}} =Truth in gender wage-gap in 1991-1995 Russia= {{:{{BOOKNAME}}/Main causes of gender pay gap in Russia}}

{{Book title|Power|Part 3}}

=The power of Christianity in modern society= {{:{{BOOKNAME}}/The power of Christianity in modern society}} =Power in Sex Education= {{:{{BOOKNAME}}/Power in Sex Education}} =Power in the anti-vaccine movement=

=Power of Gender and Sex in Sport= {{:{{BOOKNAME}}/Power of gender in sport}} =Power in Contraception= {{:{{BOOKNAME}}/Power in Contraception}} =Power in Cosmetic Surgery= {{:{{BOOKNAME}}/Power in Plastic Surgery}} =Lights will Guide You Home: The Sociological and Environmental Impact of Light in Cities= {{:{{BOOKNAME}}/Lights will Guide You Home: The Sociological and Environmental Impact of Light in Cities}} =Power of the West in response to the COVID-19 pandemic= {{:{{BOOKNAME}}/Power of the West in response to the COVID-19 pandemic}} =Power in the Tragedy of the Commons: Overfishing= {{:{{BOOKNAME}}/Power in the Tragedy of the Commons}} =Power in the Legalisation of Cannabis= {{:{{BOOKNAME}}/Power in the legalisation of cannabis}} =Power in Contact Tracing Apps= {{:{{BOOKNAME}}/Power in Contact Tracing Apps}} =Sovereign Power in the Crimean Peninsula: Approaches from International Relations and Law= {{:{{BOOKNAME}}/Sovereign Power in the Crimean Peninsula: Approaches from International Relations and Law}} =Power in tax policies= {{:{{BOOKNAME}}/Power in tax policies}}


text:
Basic Algebra/Proportions and Proportional Reasoning/Weighted Averages

What Is a Weighted Average? Weighted average is a calculation that takes into account the varying degrees of importance of the numbers in a data set. In calculating a weighted average, each number in the data set is multiplied by a predetermined weight before the final calculation is made.

Key takeaways:

 * Weighted average is the average of a set of numbers, each with different associated “weights” or values.
 * To find a weighted average, multiply each number by its weight, then add the results.
 * If the weights don’t add up to one, find the sum of all the variables multiplied by their weight, then divide by the sum of the weights.

The weighted average method is a tool used in classrooms, statistical analysis and accounting offices, among others. A weighted average helps the user gather a more accurate look at a set of data than the normal average alone. The accuracy of the numbers you arrive at with this method is determined by the weight you give specific variables in the data set.

In this article, we explore how to calculate weighted average using two methods.

What is weighted average?
A weighted average is the average of a data set that recognizes certain numbers as more important than others. Weighted averages are commonly used in statistical analysis, stock portfolios and teacher grading averages. It is an important tool in accounting for stock fluctuations, uneven or misrepresented data and ensuring similar data points are equal in the proportion represented.

Weighted average example
Weighted average is one means by which accountants calculate the costs of items. In some industries where quantities are mixed or too numerous to count, the weighted average method is useful. This number goes into the calculation for the cost of goods sold. Other costing methods include last in, first out and first in, first out, or LIFO and FIFO respectively.

Example:

A manufacturer purchases 20,000 units of a product at $1 each, 15,000 at $1.15 each and 5,000 at $2 each. Using the units as the weight and the total number of units as the sum of all weights, we arrive at this calculation:

$1(20,000) + $1.15 (15,000) + $2 (5,000) / (20,000 + 15,000 + 5,000) = ($20,000 + $17,250 + $10,000) / ($20,000 + 15,000 + 5,000) = $47,250 / 40,000 = $1.18

This equals a weighted average cost of $1.18 per unit.

How to calculate weighted average
Weighted average differs from finding the normal average of a data set because the total reflects that some pieces of the data hold more “weight,” or more significance, than others or occur more frequently. You can calculate the weighted average of a set of numbers by multiplying each value in the set by its weight, then adding up the products.

For a more in-depth explanation of the weighted average formula above, follow these steps:

 * 1) Determine the weight of each data point
 * 2) Multiply the weight by each value
 * 3) Add the results of step two together

1. Determine the weight of each data point
You determine the weight of your data points by factoring which numbers are most important. Teachers often weigh tests and papers more heavily than quizzes and homework, for example. In large statistical data sets, such as consumer behavior data mining or a population census, randomized data trees are used to determine the importance of a variable in a data set. This helps ensure the distribution of importance is unbiased. This process is typically performed with the aid of a computer program. For accounting and finance purposes, the number of units of a product is used as the weighting factor.

Example:

 * You score a 76 on a test that is 20% of your final grade. The percentage of your grade is the weight it carries.
 * An investor purchases 50 stocks at $100 each. The stocks purchased serve as the weight.

Related: 21 Job Interview Tips: How to Make a Great Impression

2. Multiply the weight by each value
Once you know the weight of each value, multiply the weight by each data point.

Example:

In a data set of four test scores where the final test is more heavily weighted than the others:

 * 50(.15) = 7.5
 * 76(.20) = 15.2
 * 80(.20) = 16
 * 98(.45) = 44.1

3. Add the results of step two together
Calculate the sum of all the weighted values to arrive at your weighted average.

Example:

7.5 + 15.2 + 16 + 44.1 = 82.8

The weighted average is 82.8%. Using the normal average where we calculate the sum and divide it by the number of variables, the average score would be 76%. The weighted average method stresses the importance of the final exam over the others.

How to calculate weighted average when the weights don't add up to one
Sometimes you may want to calculate the average of a data set that doesn't add up perfectly to 1 or 100%. This occurs in a random collection of data from populations or occurrences in research. You can calculate the weighted average of this set of numbers by multiplying each value in the set by its weight, then adding up the products and dividing the products' sum by the sum of all weights.

For a more in-depth explanation of the weighted average formula above when the weights don’t add up to one, follow these steps:

 * 1) Determine the weight of each number
 * 2) Find the sum of all weights
 * 3) Calculate the sum of each number multiplied by its weight
 * 4) Divide the results of step three by the sum of all weights

Related: Learn About Being a Data Scientist

1. Determine the weight of each number
To determine the weight of each number, consider its importance to you or the frequency of occurrence. If you are trying to calculate the average number of business leads you pursue, you may want leads that turn into sales to weigh more heavily than cold calls. To find the weighted average without added bias, calculate the frequency a number occurs as the variable's weight. This reflects its influence over the entire data set.

Example: Calculate the average time you spend exercising four days a week over the period of a month or four weeks. The time you spent exercising on any given day is the data set. The number of days you exercised for an average time is the weight you'll use.

 * 7 days you exercised for 20 minutes
 * 3 days you exercised for 45 minutes
 * 4 days you exercised for 15 minutes
 * 2 days you were supposed to exercise and did not

2. Find the sum of all weights
The next step to finding the weighted average of a data set that doesn't equal 1 is to add the sum of the total weight. From our previous example, you should have a total of 16 days spent exercising:

 * 7+3+4+2 = 16

3. Calculate the sum of each number multiplied by its weight
Using the frequency numbers, multiply each by the time you spent exercising. The combined total gives you the sum of the variables multiplied by their respective weights.

Example:

 * 20(7) = 140
 * 45(3) = 135
 * 15(4) = 60
 * 0(2) = 0
 * 140 + 135 + 60 + 0 = 335

4. Divide the results of step three by the sum of all weights
The formula for finding the weighted average is the sum of all the variables multiplied by their weight, then divided by the sum of the weights.

Example:

Sum of variables (weight) / sum of all weights = weighted average

335/16 = 20.9

The weighted average of the time you spent working out for the month is 20.9 minutes.


title: Unicode/0000-007F


text:
Template:Chesspunc

Usage
/Templates

title: Template:Chesspunc


text:
Talk:Introduction to ActionScript 2.0/Properties and Methods

I'm not sure which version of Flash this is for, but I'm using Macromedia Flash Professional 8, and the example here doesn't work. For example, when I draw an apple, I'm not immediately given the option to assign it an instance name, as this tutorial indicates it should. Instead, I first need to convert it from an object to a symbol of type "button". Only then can I actually give it an instance name.

The next problem is the code for assigning the apple object a property called juiciness, and setting its value to 5. If I just use the code in the tutorial, and then try to run it with File>Publish Preview>Flash, it gives me the error "Statement must appear within on handler". Apparently within symbols you NEED to use an "on handler" to put in any code, while code without an "on handler" can only be used in the main movie's code. At least that's the way it is as of Macromedia Flash Professional 8. I think your tutorial should much more clearly state which version of Flash it's using.

Videogamer12345 (discuss • contribs) 22:31, 20 February 2022 (UTC)


text:
Template:Interlinear/doc

Basic usage
This template formats a linguistic interlinear glossed text: Nginda-rni ngaja-mi jurliji-rdarra diyim ka-rdu

DEM(M)-FOC see-IRR bird-PL fly 3SG-go

'Look at all the birds flying!'

Te ni-kekoo te̱e ún
 * On lines to be interlinearised, any wiki markup or templates should never span word boundaries. Мarkup or templates that apply to a sequence of words must be repeated for each word: (It is also possible to apply formatting to an entire line, see below)

And past-arrived.PL man he

"The men arrived"

The characters <, > and = should not be used directly. They can be substituted as follows:

To let a multi-word expression be treated as a single word, surround it in {curly brackets}. Similarly, use {} for an empty word: Dit is een voorbeeldje in het Nederlands

This is a {little example} in {} Dutch.

The template can be invoked with any number of unnamed parameters, which are interpreted as lines of text. If there is only one unnamed parameter, then it will be rendered in-line and treated as a gloss line:  gives: house-ATTR master-ABS. If they are more than one, then all will be interlinearised except the last one, which is assumed to be the free translation. To force the interlinearisation of all lines, supply an empty last unnamed parameter: Ù-dììny 	Juáàny 	bèʔcw.

COMPL-hit 	Juan 	dog

Layout
A line of text to be displayed above the interlinear block is given using top, one to be displayed immediately below the free translation is set using bottom. If any of these need to contain more than a singe line, then line breaks can be introduced using br. Example numbering can be set using number. The parameter consists in one or more characters to be displayed in the left margin. kʼetʼu-q ɣˤay ħaƛu-ł-xo

cat-POSS:ESS milk:ABS drink-POT-PRS

"The cat can drink milk."

The indentation of the interlinear block (measured in ems) can be modified using indent. Currently, the default value is 3 if number is set, and 0 otherwise. This behaviour is set to change: the next version of the template will apply indentation by default.

The spacing between consecutive word stacks can be adjusted using spacing; it is measured in ems and its default value is 1. To visually set off the interlinear display from surrounding text, the yes parameter can be used. It surrounds the whole interlinear text in a box with a wikitable-like background colour. Nyama-baji imimikin-bili-rni-rni ardalakbi-wurru-ju

DEM-PL old.woman-ANIM.DU-F-ERG hot-3PL-do

'The two old women feel hot.'

To add a comment after a given line, use cN (where N is the sequence of the line: the content of c1 will be appended at the end of first line, c2 – at the end of the second line etc.): Shte da e vidiyal

FUT COMPL AUX see.PTC.M.SG

'He must have seen it.'

Line formatting
Formatting can be set for an entire line using the styleN parameter, which applies CSS style properties to line N (style1 for the first line, style2 for the second one, etc): Įxę̀ę eya ı̨-lè

yesterday sick/painful PFV.3.SBJ-COP.PFV

'Yesterday he was sick.'

Similarly, CSS classes can be specified for line N using classN. Classes should be given without any quotation marks.

Italics are by default applied to the first line, unless disabled by no. Any line can be italicised using yes (where N is the number of the line). On italicised lines, tone numbers will be formatted as superscripts, unless tone-superscripting is set to no. To turn off italics for a particular word within an italicised line, use noitalic.

To specify the language of a given line, you can use langN (with N being 1 for the first line, 2 for the second one etc.). The parameter should be the ISO code of the language, as in the familiar Template:Lang. If the unnumbered lang is given, then it is applied to the first line. If line N employs IPA, then the effect of Template:IPA can be mimicked by setting yes. If transliteration has been used, then the transliteration scheme can be specified with the translN parameter (similarly to Template:Transl).

Glossing abbreviations
Linguistic glosses typically abbreviate grammatical category labels, like this: ACC, instead of the full name 'accusative'. The line containing such glosses is specified using yes (where N is the number of the line within the interlinear text). If no line is specified, then it is assumed such glosses are found in the second line (this can be bypassed with no). Within the lines so specified, any sequence of upper case letters will be interpreted as a grammar gloss and formatted in.

Additionally, the template will attempt to recognise the meaning of each abbreviation by looking it up in several places (more details below), and if the abbreviation is found, it will be formatted with a dotted underline and the "label" of this abbreviation will be displayed in a tooltip, like this: DAT. Alternatively, the abbreviation can be turned into a link to the Wikibook about the corresponding grammatical category, like this: DAT. To choose the latter behvaiour, use the following parameter: link. It is possible for separate lines to employ different styles, in this case the parameters used will be glossing2, glossing3, etc.

If a particular glossing abbreviation is to be treated differently from the rest, then gcl can be used: ngagun-yi nga-nanda-yi nung

1sg.NOM-ERG 1sgA.3sgO-see-PST 3sg.ACC

'I saw him/her.' ngagun-yi nga-nanda-yi nung

1sg.NOM-ERG 1sgA.3sgO-see-PST 3sg.acc

'I saw him/her.' In this example, marks up acc as a glossing abbreviation (it wouldn't have otherwise been interpreted as such because it is lower-case). is used to define the meaning of the unusual abbreviation 1sgA, which wouldn't be recognised even in upper case. displays the abbreviation as a link to the Wikibook. applies formatting to a part of a glossing abbreviation; if weren't used here then the wikimarkup would have forced P to be treated as a separate abbreviation from ST.

If the grammatical category labels are not abbreviated but written out in full (like that: ACCUSATIVE) then glossing should be set to no abbr, which will only apply small-caps formatting: wǒ yǐjing jiàn-guò {Zhāng Sān} le.

I already see-EXPERIENTIAL {Zhang San} RESULTATIVE.

Additional style parameters can be applied to all gloss abbreviations using glossing-style. The default formatting using small caps can be disabled with no, and the default underlining can be turned off using no. To exempt a particular abbreviation from being treated as a grammatical gloss, use no gloss.

The pesky boxes with glossing messages that are shown in preview mode can be turned off with no.

Custom abbreviations
The template recognises some of the most commonly used abbreviations. However, it is recommended to always specify the meaning of each abbreviation used. There are several ways to do that: wǒ yǐjing jiàn-guò {Zhāng Sān} le.
 * Defining at the article level. If an article uses a number of interlinearised examples and they share a set of abbreviations, then these can be defined once for the whole article using the following format:
 * The list can contain any number of abbreviations; if a wikibook needs to be specified, it is added after a colon, for example: NEG:negator:Negation (linguistics). This whole code can be placed anywhere in the article, but it is customary to put it at the end, after the references but before any categories. It is visible only in edit mode, it is not displayed in the article.
 * Defining at the level of a single instance of the template. This is done using abbreviations (or ablist). The list of custom abbreviations takes the same format as above: ABBREVIATION1:meaning1:wikibook1; ABBREVIATION2:meaning2:wikibook2... (specifying a Wikibook is optional and has no effect unless link):

I already see-EXP {Zhang San} RES.
 * Defining a single instance of an abbreviation. This is done using gcl, as seen above
 * Defining an abbreviation globally. This is done by the addition of an entry to the module's data page. The abbreviation will be recognised by any use of the templates, anywhere on the English wikibook. This should be done only for completely unambiguous abbreviations.

Troubleshooting
This is a list of problems that are likely to be encountered:
 * One of the lines went missing.
 * Does this line contain anywhere an equals sign? If yes, then all instances of the equals sign should be replaced with.

 * I've applied bolding/italics to a phrase and now the formatting is all over the place.
 * Any formatting should be applied separately to each word.

 * I receive the error "Mismatch in the number of words".
 * Interlinearised lines don't contain the same number of words. If this is intended, then consider filling the empty slots with {}. If this is not intended, then the following points might help track down the cause:
 * if formatting or a template is applied to a piece of text then this text is treated as a single word:
 * non-breaking spaces are not treated as word separators;
 * if a sequence of words is enclosed in {curly brackets} then it's treated as a single word.

 * I receive the error "Unknown glossing abbreviation(s)".
 * See above for details, but in short:
 * If this was not intended as a glossing abbreviation, enclose it in no gloss.
 * To set the meaning of one instance of a glossing abbreviation, format that instance with gcl, for example.
 * If the abbreviation occurs several times within the same example then it might be easier to use the abbreviations parameter, for example: PF:perfective aspect.

TemplateData
{	"params": { "1": {			"label": "First line of interlinear text", "type": "string", "required": true, "description": "It is italicised by default (unless the parameter \"italics1\" is set to \"no\")." },		"2": {			"label": "Second line of interlinear text", "type": "string", "suggested": true, "description": "By default, this is expected to contain the glosses. If there are any glossing abbreviations, they will be expanded (unless the parameter \"glossing2\" is set to \"no\")." },		"3": {			"label": "Third line of text", "type": "string", "suggested": true, "description": "If it is the last line, it is assumed to be the translation and so will not be interlinearised. To force the last line to be interlinearised, then add a new, empty, line after it." },		"4": {			"label": "Fourth line of text.", "type": "string" },		"5": {			"label": "Fifth line of text", "type": "string" },		"lang": { "label": "Language of the text", "description": "ISO 639 code of the language.", "type": "string" }	},	"description": "This template formats interlinear glossed text.\nOnly a few of the capabilities of this template are documented here. For all options, see its documentation. Alignment is automatic, so there is no need to add padding either inside or around the template." }

title: Template:Interlinear/doc


text:
Talk:Learning anatomy/Table version

why do the headers keep embiggenning?
wack Arlo Barnes (discuss • contribs) 00:27, 21 February 2022 (UTC)

title: Talk:Learning anatomy/Table version


text:
Cookbook:Marshmallow Creme

Marshmallow creme, also known as marshmallow fluff, is a marshmallow-like confectionery spread. Unlike traditional marshmallows, marshmallow creme is spreadable rather than solid and chewy. It can be used as a filling or a topping, and it is sometimes also used as an ingredient in fudge.

title: Cookbook:Marshmallow Creme


text:
Cookbook:Chili Mix

Most American grocery stores sell little single-use packets of instant spice mix for seasoning chile con carne. This recipe is for a homemade version of the chili spice.

Ingredients

 * 2 tablespoons chili powder
 * 1 tablespoon dehydrated onion (minced or powdered)
 * 2 teaspoons seasoning salt
 * 2 teaspoons cumin powder
 * 1–2 teaspoons ground red cayenne pepper or crushed/powdered ancho chilli pepper
 * 1 teaspoon dried oregano
 * 1 teaspoon ground black pepper
 * ½ teaspoon salt
 * ½ teaspoon dehydrated garlic (minced or powdered)
 * ½ teaspoon ground cinnamon

Procedure

 * 1) Mix all ingredients and store in an airtight jar.
 * 2) Use 1–3 tablespoons of Chili Mix per 1 lb of meat (to taste).

Notes, tips, and variations

 * If you don't have seasoned salt, substitute powdered soup bouillon or increase the salt, pepper, and garlic.

title: Cookbook:Chili Mix


text:
C++ Language/Indirection/SmartPointers/SmartCompilerTemporary

C++ creates a compiler-temporary for the  portion of. To guard against memory leaks from exceptions occuring before that compiler-temporary is given to the smart pointer, use  in place of   (a   compiler-temporary is already a smart pointer as soon as it exists).

Additional information about smart compiler-temporaries (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/CustomDestruction

Normally you rely on a smart pointer to decide both "when" and "how" to deallocate. But it is possible for you to provide a custom callable-object for the "how" part.

Additional information about smart pointers using custom destruction (includes interactive examples)


text:
C++ Language/Indirection/SmartPointers/TemplateParameter

You can access a smart pointer's template-parameter by.

Additional information about accessing a smart pointer's template-parameter


text:
C++ Language/Expressions

Much of a C++ program consists of a sequence of "expressions". An expression is some kind of "operator", along with the "operands" that it processes as its input. When the program is running, the computer "evaluates" the expression (often producing a "value" as the result of that evaluation).

 * 1) Precedence
 * 2) Chain of Assignment

title: C++ Language/Expressions


text:
C++ Language/Expressions/Precedence

C++ follows the standard precedence rule of mathematics, where  is parsed the same as if it had been written. Other precedence rules govern all aspects of expression evaluation.

Additional information about precedence rules (includes interactive examples)

title: C++ Language/Expressions/Precedence


text:
C++ Language/Expressions/ChainOfAssignment

The "compound assignment"  is an abbreviation for.

Programmers usually think about  only in terms of its effect (changing the value stored in  's memory), but that expression does also evaluate to a value. In fact, it evaluates to a "lvalue" which means that  is allowed to occur on the left-hand-side of some other assignment (although it would be weird to do so).

Additional information about lvalues (includes interactive examples)


text:
C++ Language/ProgramFlow

When a C++ program is running, you should think of the computer as executing its statements in a flow that generally goes linearly from first to last statement. However, the language provides several programming constructs which can alter that program flow.

 * 1) Loops
 * 2) The break Statement
 * 3) Return Value
 * 4) Parameters
 * 5) Function Overloading
 * 6) Function-Pointer
 * 7) Deprecating a Function

title: C++ Language/ProgramFlow


text:
C++ Language/ProgramFlow/Loops

A "loop" is a programming construct that repeats a body of statements over and over again, testing some condition each time. Eventually, the result of testing that condition will determine that repetition should stop.

 * 1) Basic Loops
 * 2) Looping over a Collection

title: C++ Language/ProgramFlow/Loops


text:
C++ Language/ProgramFlow/Loops/BasicLoops

Loops can be written as  or as. The initialization and updating of a loop can be consolidated into.

Additional information about loops (includes interactive examples)


text:
C++ Language/ProgramFlow/Loops/LoopingOverCollection

Any STL collection that provides iterators via  and   (e.g.,  ) can be iterated by.

Additional information about looping over a collection (includes interactive examples)


text:
C++ Language/ProgramFlow/BreakStatement

A  statement aborts the execution of a loop. Instead of finishing the remaining statements in the loop's body, program flow immediately jumps to the code that follows the loop (ignoring the loop's condition).

 * 1) A Break in a Nested Loop
 * 2) Fallthrough in a Switch

title: C++ Language/ProgramFlow/BreakStatement


text:
C++ Language/ProgramFlow/BreakStatement/BreakInNestedLoop

When there is nesting, a  statement only terminates the innermost loop.

Additional information about breaking out of a nested loop


text:
C++ Language/ProgramFlow/BreakStatement/FallthroughInSwitch

A  statement is an efficient substitute for many   chains. In a  statement, each body is a sequence of statements preceded by a   label. If you don't terminate that sequence of statements by, then program flow will fall-through and also perform the next sequence of statements. This is often a programming bug, so when you intentionally do this, write  in place of.

Additional information about fallthrough (includes interactive examples)


text:
C++ Language/ProgramFlow/ReturnValue

It would be unsafe to return a reference to a local variable, but you can return a reference to a data member.

Additional information about valid return types (includes interactive examples)

title: C++ Language/ProgramFlow/ReturnValue


text:
C++ Language/ProgramFlow/Parameters

When a function is defined, its definition can specify one or more "parameters". A parameter acts somewhat like a local variable, except that parameter's initial value comes from data that is "passed" in from the function-call statement.

 * 1) Default Parameter
 * 2) Unused Parameter
 * 3) Variable Number of Parameters

title: C++ Language/ProgramFlow/Parameters


text:
C++ Language/ProgramFlow/Parameters/DefaultParameter

When defining a function having a parameter, you can specify a default value that will be used if the caller doesn't provide a value for that parameter. For a member function, this should appear in the class definition as  (use ordinary syntax when implementing this function).

Additional information about default parameters (includes interactive examples)


text:
C++ Language/ProgramFlow/Parameters/UnusedParameter

Many compilers will warn you if you define a parameter that isn't used anywhere inside your function. If you are doing this intentionally, mark that parameter with.

Additional information about unused parameters (includes interactive examples)


text:
C++ Language/ProgramFlow/Parameters/VariableNumberOfParameters

A parameter's type could be. This allows for passing either as  or as.

Additional information about having a variable number of parameters (includes interactive examples)


text:
User:Unkle Peter

Welcome
I am currently interested in Python programming for audio projects.

I am using the guizero and pygame libraries.

To leave me a message, please edit my Discussion tab above.

title: User:Unkle Peter


text:
User talk:Unkle Peter

Public Messages
Edit this page to leave me a message.

(You don't need a Wikibooks user account, but you may find it convenient to watch for changes in pages you are interested in.)

Unkle Peter (discuss • contribs) 11:11, 21 February 2022 (UTC)

title: User talk:Unkle Peter


text:
User:034kslgm

034kslgm

title: User:034kslgm


text: Proto-Germanic/Printable version

title: Proto-Germanic/Printable version


text: South American Plant Names/Printable version


text:
Saint Michael: Early Anglo-Saxon Tradition/Acknowledgements

The original author of this work is Professor Raymond J S Grant, formerly of the University of Alberta Department of English and Film Studies, and graduate of the Universities of Aberdeen and Cambridge (Peterhouse, 1970/1, under the supervision of Dorothy Whitelock). The work appears here with permission of his estate.

The editors of this work are grateful for the time and expertise so generously offered by Tara Gale, Tim Sobie, Pamela Farvolden, Stephen Reimer, Anne Correia, and Ray Siemens.

Tara Gale's Master of Arts thesis—completed under the supervision of Raymond Grant, Stephen Reimer, and others in 2002—is entitled In praise of the Archangel Michael: piety and political accommodation in 11th-Century England. It is available here, https://era.library.ualberta.ca/items/d5409272-7642-4cc6-b830-3d0421c5f25b/view/7412f5c4-68db-4c61-bd03-9e186c028f83/MQ69642.pdf, and via other repositories. Then, and since, she has been a research assistant to elements of this work.

Should auld acquaintance be forgot

And never brought to mind?

Should auld acquaintance be forgot,

And days o' lang syne?

---

That Man to Man the warld o'er,

Shall brothers be for a' that.

To warm memories of friendship and friends. The family dedicate this book to the significant and enduring friendship between Raymond Grant and Reynold Siemens.


text:
C++ Language/ProgramFlow/FunctionOverloading

"Overloaded" functions are multiple function implementations that all share a common name. They each have their own unique "signature" (the types of the parameters).

 * 1) Discrimination Criteria
 * 2) Across Inheritance


text:
C++ Language/ProgramFlow/FunctionOverloading/DiscriminationCriteria

When an overloaded function is called, the compiler is able to choose which implementation to use, based on the types of values passed to it. However, this overloading cannot discriminate between two implementations based only on return types.

Additional information about overloaded function discrimination (includes interactive examples)


text:
C++ Language/ProgramFlow/FunctionOverloading/AcrossInheritance

Instead of overloading each other, one function hides the other if it is in a derived-class.

Additional information about hiding instead of overloading (includes interactive examples)


text:
C++ Language/ProgramFlow/FunctionPointer

In traditional C++, a function could be passed-around using "function-pointer" variables. For example, this type alias specifies a pointer to a function that converts a float-pointer into an integer:.

Additional information about function-pointers


text:
C++ Language/ProgramFlow/DeprecatingFunction

An undesirable part of an API can be marked with.

Additional information about deprecating a function (includes interactive examples)


text:
C++ Language/Objects

An individual data member of an object is accessed by. The dereference and member-access operators can be combined into.

 * 1) Accessibility
 * 2) Unwanted Compiler-Generated Functions
 * 3) Constructors
 * 4) Destructors
 * 5) Const Members
 * 6) Static Members
 * 7) Inheritance
 * 8) Operator Overloading
 * 9) Nested Classes
 * 10) Pointer to Members
 * 11) Low-Level C Structures

title: C++ Language/Objects


text:
Cookbook:Grains of Paradise

Grains of paradise, also known as melegueta pepper or by its latin name Aframomum melegueta, is a spice native to West Africa. It has a peppery flavor. The spice may be sold whole, similar in appearance to peppercorns, or ground.

title: Cookbook:Grains of Paradise


text:
WikiLang/Palauan/Animals

This page is about the names of animals in the Palauan language.

title: WikiLang/Palauan/Animals


text:
C++ Language/Objects/Accessibility

In the class definition, you can precede a group of members by  to disallow usage of that member from anywhere outside of that class' own member functions. Or, use  accessibility to also allow access to member functions of derived classes. The  accessibility allows access from anywhere.

Additional information about accessibility (includes interactive examples)

title: C++ Language/Objects/Accessibility


text:
C++ Language/Objects/UnwantedCompilerGeneratedFunctions

The compiler automatically generates several member functions, if the programmer hasn't manually programmed them (e.g., a default constructor). If you want to prevent the compiler from doing that, write that function's signature followed by.

Additional information about compiler-generated functions


text:
C++ Language/Objects/Constructors

A "constructor" is a special member function, which a class uses to initialize its data members as part of instantiating an object from that class.

 * 1) Ordering
 * 2) Initialization by Copy-Constructor
 * 3) Initialization by One-Parameter-Constructor
 * 4) Keeping Default Constructor
 * 5) Delegation within Class
 * 6) Memory Full
 * 7) Placement New

title: C++ Language/Objects/Constructors


text:
C++ Language/Objects/Constructors/Ordering

When an object is being instantiated from a class definition, you should usually initialize its data members. Immediately after reserving enough memory to store the object, C++ will automatically call a "constructor" function to perform that data-member-initialization. You implement your constructor as a member function having the same name as the class name, optionally with parameters, having no return type at all.

When there's a hierarchy of classes, bass-class-constructors will be called before a derived-class-constructor.

Additional information about the order in which constructors get performed


text:
C++ Language/Objects/Constructors/InitializationByCopyConstructor

"Implicit initialization" and "explicit initialization"  are equivalent in the sense that they both invoke  's "copy-constructor". The copy-constructor's signature is. This same copy-constructor will also be called whenever an object is passed-by-value into some function.

Additional information about copy-constructors (includes interactive examples)


text:
C++ Language/Objects/Constructors/InitializationByOneParameterConstructor

A one-parameter-constructor is essentially converting the type of some data (from that parameter's type, into this class type). To prevent client code from unintentionally doing this type-conversion when that client uses implicit-initialization syntax, mark this constructor definition with the  keyword.

Additional information about a one-parameter-constructor (includes interactive examples)


text:
C++ Language/Objects/Constructors/KeepingDefaultConstructor

The compiler provides a do-nothing implementation of the "default constructor" (one that has no parameters), if the programmer hasn't manually provided a custom implementation for it. But traditionally, if the programmer writes any other constructor (having some other overloaded signature of parameters), then this built-in default constructor was not provided by the compiler.

If you do write some other constructor, but you still also want the compiler to provide its built-in default constructor, request it with.

Additional information about keeping the default constructor


text:
C++ Language/Objects/Constructors/DelegationWithinClass

With a modern compiler, a constructor could now delegate its implementation to some other constructor of the same class.

Additional information about delegation of the constructor (includes interactive examples)


text:
C++ Language/Objects/Constructors/MemoryFull

The C language's  returned   if memory was full when that allocation was attempted.

C++'s  instead throws a   exception.

Alternatively, you could use  to specify a callback that will be repeatedly called until enough memory is available.

Additional information about memory being full


text:
C++ Language/Objects/Constructors/PlacementNew

C++'s  operator allocates memory, and then executes some constructor within that memory. Low-level software might already have some memory pre-allocated for a new object, only wanting to run its constructor. To do so, call a "placement new" as.

Additional information about placement new


text:
C++ Language/Objects/Destructors

If a class constructor's implementation has any side-effect (e.g., allocation of memory, or opening of a file), then you usually desire the opposite side-effect to happen whenever that class' instances are going to get destroyed. The compiler knows when it's going to be destroying an object, but the programmer needs to specify that side-effect behavior within a "destructor" function which is written as.

Additional information about destructors

title: C++ Language/Objects/Destructors


text:
C++ Language/Objects/ConstMembers

Both data members and member functions could be marked by the  keyword, but the implications of that depend on which kind of member it is.

 * 1) Const Data Members
 * 2) Const Member Functions

title: C++ Language/Objects/ConstMembers


text:
C++ Language/Objects/ConstMembers/ConstDataMembers

For data members that are constants or references, you must initialize them in a constructor's "initializer-list", which is written as.

Additional information about const data members


text:
C++ Language/Objects/ConstMembers/ConstMemberFunctions

A member function automatically has access to a  pointer variable whose type is   and which is automatically pointing at the   object being manipulated by this member function. But you could have defined the member function as, in which case the type of   becomes   (that function's body can view data members but not alter them).

This restriction can be ignored for individual data members (on a case-by-case basis) but marking the data member with.

Additional information about const member functions


text:
C++ Language/Objects/StaticMembers

Both data members and member functions could be marked by the  keyword, but the implications of that depend on which kind of member it is.

 * 1) Static Data Members
 * 2) Static Member Functions

title: C++ Language/Objects/StaticMembers


text:
C++ Language/Objects/StaticMembers/StaticDataMembers

A "static-data-member" is a data member marked by the  keyword. It describes one value that is shared by all objects of that class. Generally, a static-data-member must be initialized outside the class definition (by writing  at the top of some implementation file).

Additional information about static-data-members


text:
C++ Language/Objects/StaticMembers/StaticMemberFunctions

Most member functions conceptually manipulate one specific object, but a member function marked by the  keyword is for computation that is collectively about all objects of that class. The compiler doesn't provide any  pointer to a static-member-function, so a static-member-function can only access static-data-members. Whereas an ordinary member function is invoked on a specific object, any code may invoke a static-member-function without having any object (simply calling ).

Additional information about static-member-functions


text:
C++ Language/Objects/Inheritance

A "derived" class "inherits" all members from its "base" class. A derived class is defined as.

 * 1) Polymorphism Syntax
 * 2) Qualification Syntax
 * 3) Restricted Overriding
 * 4) Multiple Inheritance

title: C++ Language/Objects/Inheritance


text:
C++ Language/Objects/Inheritance/PolymorphismSyntax

Frequently, an object is allocated by instantiating the derived class, but "pointed-at" by a pointer variable whose type is "pointer-to-base-class":. If  and   have provided two different implementations of the same   member function, then   would call the base class' implementation. But if the member function had been marked by the  keyword, then   would instead "polymorphically" call the derived class' implementation.

Additional information about polymorphism syntax


text:
C++ Language/Objects/Inheritance/QualificationSyntax

An overriding implementation of  can non-polymorphically refer to a base class' implementation as.

Additional information about qualification syntax


text:
C++ Language/Objects/Inheritance/RestrictedOverriding

A library author can use the  keyword to prevent an application programmer from further overriding a virtual-function.

An application programmer can use the  keyword to require that the virtual-function he's implementing must have also existed within the base class.

Additional information about restricted overriding


text:
C++ Language/Objects/Inheritance/MultipleInheritance

A C++ class may inherit from multiple base classes. However, that practice is often discouraged unless all but one of the base classes are "interfaces" (in C++, an "interface" takes the form of an "abstract class" having "pure" virtual functions that define an API without providing their own implementations).

Additional information about multiple inheritance


text:
C++ Language/Objects/OperatorOverloading

Programming custom implementations for operators is the mechanism for allowing a custom C++ class to be used as a "value type" (which then can behave similar to built-in primitive types like ). For example, client code expects to be able to do ; if you want your custom class to also behave that way, then define its.

Additional information about operator overloading (includes interactive examples)


text:
C++ Language/Objects/NestedClasses

An inner class definition may be nested within some outer class definition. The member within that nested class is called  (those qualifications are unnecessary for code within that class' member functions).

Additional information about nested classes

title: C++ Language/Objects/NestedClasses


text:
C++ Language/Objects/PointerToMembers

It is very common to use a type which is "pointer to " (the type's name is  ). Must less common (but still possible) is using a type which is "pointer to  data member of class  " (the type's name is  ).

Additional information about pointers to members (includes interactive examples)

title: C++ Language/Objects/PointerToMembers


text:
C++ Language/Objects/LowLevelCStructures

These aspects of class definition are vestiges of the C programming language. They still exist in C++, even though they are not commonly used.

 * 1) Union
 * 2) Flexible-Array-Member
 * 3) Bitfield


text:
C++ Language/Objects/LowLevelCStructures/Union

A  is the same as   except for default accessibility.

A  is also the same, except all members in the union overlap in memory (space in memory is made for the largest member). Only one member can have meaningful data at one time.

Additional information about union


text:
C++ Language/Objects/LowLevelCStructures/FlexibleArrayMember

A "flexible-array-member" is a data member which is an array having unspecified size. A flexible-array-member must be the last member, and there must be at least one normal data member before it.

Additional information about flexible-array-members


text:
C++ Language/Objects/LowLevelCStructures/Bitfield

A "bitfield" structure member  is useful for alignment.

Additional information about bitfields


text:
User talk:75.150.202.18

Help I've been banned

title: User talk:75.150.202.18


text:
User talk:Mykola7

Welcome!
Welcome to Wikibooks, Mykola7!

 First steps tutorial Wikibooks is for collaborative development of free textbooks.

You do not need technical skills to contribute. You can easily change most books. Please introduce yourself, and let us know what interests you.

If you already contribute at other Wikimedia projects, our Wikimedia Orientation should quickly get you started. (Would you like to provide feedback on this message?)

  Getting help   Made a mistake?   Goodies, tips and tricks
 * Read the Using Wikibooks book for a friendly introduction to the project, or our help pages for more information.
 * You can get friendly help from the community in the user assistance room or our IRC channel.
 * Upload freely licensed files to Wikimedia Commons. You may request permission to upload fair use files locally. Please include author and source information and a non-free use rationale for non-free files.
 * You can restore a previously saved version.
 * Pages should follow the  naming convention.
 * Need to rename a page? Use the move tab (is available once your account is 4 days old - until then, ask for help).
 * To request a page be deleted, add to the top of the page.
 * Was a page you made deleted? Please read the deletion policy, and check the deletion log to find out why. Also check the RFD archives if applicable. You can request undeletion at WB:RFU, or ask the administrator who deleted the page.
 * Please fill in the edit summary and preview your edits before saving.
 * Sign your name on discussion pages by typing ~~~~
 * User scripts can make many tasks easier. Look at the Gadgets tab of my preferences; check off the boxes for the scripts you want, and hit save!

Thanks for your contributions -- Jules (Mrjulesd) 17:32, 22 February 2022 (UTC)

title: User talk:Mykola7


text:
User talk:SHEIKH

Welcome!
Welcome to Wikibooks, SHEIKH!

 First steps tutorial Wikibooks is for collaborative development of free textbooks.

You do not need technical skills to contribute. You can easily change most books. Please introduce yourself, and let us know what interests you.

If you already contribute at other Wikimedia projects, our Wikimedia Orientation should quickly get you started. (Would you like to provide feedback on this message?)

  Getting help   Made a mistake?   Goodies, tips and tricks
 * Read the Using Wikibooks book for a friendly introduction to the project, or our help pages for more information.
 * You can get friendly help from the community in the user assistance room or our IRC channel.
 * Upload freely licensed files to Wikimedia Commons. You may request permission to upload fair use files locally. Please include author and source information and a non-free use rationale for non-free files.
 * You can restore a previously saved version.
 * Pages should follow the  naming convention.
 * Need to rename a page? Use the move tab (is available once your account is 4 days old - until then, ask for help).
 * To request a page be deleted, add to the top of the page.
 * Was a page you made deleted? Please read the deletion policy, and check the deletion log to find out why. Also check the RFD archives if applicable. You can request undeletion at WB:RFU, or ask the administrator who deleted the page.
 * Please fill in the edit summary and preview your edits before saving.
 * Sign your name on discussion pages by typing ~~~~
 * User scripts can make many tasks easier. Look at the Gadgets tab of my preferences; check off the boxes for the scripts you want, and hit save!

Thanks for your contributions -- Jules (Mrjulesd) 17:34, 22 February 2022 (UTC)

title: User talk:SHEIKH


text:
C++ Language/Templates

A "template" is C++ source code that doesn't get compiled into machine language at the time it's encountered by the compiler. Instead, the compiler remembers that code. The template contains one or more template-parameters; later, the compiler will perform a compilation of that code when it first needs a "specialization" of it. That specialization involves substituting some C++ type in place of each template-parameter.

 * 1) Templated-Functions
 * 2) Templated-Classes
 * 3) Templated-Variables
 * 4) Template-Parameters
 * 5) Traits
 * 6) Metaprogramming
 * 7) Concepts

title: C++ Language/Templates


text:
C++ Language/Templates/TemplatedFunctions

A templated-function looks like any ordinary function, but with "template-parameter" placeholders for some types:. No compilation happens here where this templated-function is being defined; instead, this  will get compiled (with "specialization"   applied) during the first occurrence of that usage, as in. In this case, you could have simply written, since the compiler could infer   from those parameter types.

Additional information about templated-functions (includes interactive examples)


text:
User:ELLANDREJTEAH

Career Development Inventory

'''choosing a career can be difficult when you are not sure about what you want to be doing for the rest of your life. Growing up as a kid, I always dreamed of becoming s designer, journalist, and writer. I was a gifted kid and started drawing at a young age. I was very good at it, and my classmate always wanted me to draw pictures for them in exchange for some personal objects like pencil, charcoal and sometimes money. I was then thinking of becoming a famous drawer. But my dad was not supporting me in that dream and never bought me what I needed to draw better. A few years later, when I became a teenager and didn’t like to be wearing the same accessories with my friends, I started to modify my shoes, handbags, and everything I was wearing to school. At the same time, I was writing my first book, first poem, the first song, etc...I had a thousand ideas coming into my head, and I always preferred to be alone. I was constantly trying to organize my thoughts. I also wanted to become a lawyer to defend women and children, but I got stopped by the wrong sides of the Job. I don’t want to be constantly manipulating words to win my process it is expected that lawyers know that their client is a criminal or wrong,, but they still defend that person. I am still thinking about becoming a family lawyer, it is a well-paid job,, and I would be able to help people in need. I would just have to make sure the person I will be defending is honest and good people. However, I am still willing to continue in the fashion industry.'''

'''I feel more comfortable and confident as a fashion designer. I have Been dreaming of becoming a fashion designer since I was a kid, and want to pursue my dream. As I finish my college journey in the future I will decide if I only want to focus on only one of my childhood career dream or do as much as can. Like old African people like to say, “you can’t chase two hyenas at once”.for them, doing so you have big chances to miss both hyenas. so better focus on one to give yourself a better and bigger chance to successfully catch it since hyenas are fast and cunning animal. this adage is valid in professional life since you can’t be successful if you want to be doing a thousand things at once without a solid base, money. “only rich people can have a thousand hands, legs and mouths” In fact after you become rich you can pay millions of people to think and act for you and so you can pursue a thousand dreams when you have the material and human resources.'''

'''That being so, I will focus on one dream for now and after go for the others. Doing this exercise reminded me of all my childhood dreams and passions,it can of reminded me of myself since the career I have been matched with is what I have been already thinking of doing. It helps to project yourself in the right career. And I believe these quizzes should be given to young students in middle school and high school because a career choice has to be made before college.in fact, the earlier you plan your career the better it is since you will get more time to love it, feel it and most importantly learn about that career.'''

To conclude I will say parents need to encourage their children accomplishing their dreams without interfering in their choices, let them do what they really enjoy doing and push them to become the best at what they want to do as long as it does not hurt anyone.

title: User:ELLANDREJTEAH