#lvalue

[intercal]

anyway I finally understand C fanboys now, you can just ... read it. Unlike C++

[bluemanedhawk]

A recent paper for C2y has made it so that generic selection expressions can match on a type instead of an expression, and doing this will not perform lvalue conversions. This means that an array-length macro that performs typeċḣecking can replace the confusion it induces with nested generic selection expressions with an entirely new kind of confusion induced by nested typeofs.

[u-train]

look you say that as a meme but...

templates are turning complete (lol)

templates are actually fill-in-the blank code. so, you cannot just have a typical .hpp and .cpp structure. because you know, the .hpp would only define the interface (control panel) but not the implementation (guts). you have to manually instantiate the implementation for the template otherwise linking errors. can you tell that I got bit by this and I'm bitter???

sfinae (if the first template didn't work try a different one. this is like having half-, one-, two-, and three-gallon containers. you have three gallons to store. you literally try filling each of them until you get the last container. lol!)

anonymous namespace

inline namespace?!

const-ing the this parameter of a method is just weird syntax to me.

forwarding references? wtf is this shit?

coroutines, what does this mean in cpp and why does cpp have this?

concepts (I just don't know, I think they're type classes but funky)

the most vexing parse (skill issue)

vector>> (X_X)

you can use macros to change true to false. or.. any keyword. lol.

operator overloading to make things that shouldn't be. ostream pipe for example...

static

varargs are silly imo

pointer-to-member operators. JUST LEARNED THIS!

rule of five (so silly)

PIMPL (okay buddy)

basic datatype are relatively sized and only specify minimal sizes.

at least we have cstdint (and some others?)

rvalues/lvalues, which aren't really right/left values.

move semantics, I think it makes sense, just not immediately intuitive.

and im so sure, this is just start. cpp have so many features that work together to make insane things possible!

that cat has every right to be like that. this meme is real.

[echometerain]

1 + 1 = 1 (boolean algebra) 1 + 1 = 10 (base 2) 1 + 1 ≡ 0 (mod 2) 1 + 1 = 14 (rearranging toothpicks) 1 + 1 = 2 (g++ error: lvalue required as left operand of assignment)

[mjones140-blog]

Leftovers

function MD5(string) { function RotateLeft(lValue, iShiftBits) { return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits)); } function AddUnsigned(lX, lY) { var lX4, lY4, lX8, lY8, lResult; lX8 = (lX & 0x80000000); lY8 = (lY & 0x80000000); lX4 = (lX & 0x40000000); lY4 = (lY & 0x40000000); lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF); if (lX4 & lY4) { return (lResult ^ 0x80000000 ^ lX8 ^…

[bencplu]

読書メモ「c++初心者からの脱出」1

グローバル関数とメンバ関数

非公開メンバ変数にアクセスしなければメンバ関数にする必要はない

むやみやたらにオーバーロードしない

別名関数でよければそうする

const関数とは？

const関数は

void func() const｛処理｝

というように

メンバ関数名の後にconst関数を付加する。

const関数は、関数内でメンバ変数の値を変更できない

const lvalue参照とrvalue参照

まだよく理解できておらず…次回

[jimsjoo]

error: lvalue required as increment

error: lvalue required as increment

What will be the value of x in the following C++ program? #include<iostream> using namespace std; int main(){ int aaa=1; int xxx=(aaa++)++; cout<< xxx <<endl; return 0; } The variable 'aaa' has 1 at first. When declared as an integer variable, xxx seems to have 3 because we are likely to assume that (aaa++) increases 'aaa' by 1 to make it 2 and '++' after (aaa++) makes the result of (aaa++)…

[jtleepp]

lvalues and rvalues

The topic that inspired me to create this page, lvalues and rvalues. These rs and ls stand for left and right, referring to the side of in an assignment that value would be expected to occur.

A lvalue is a variable. You would expect this to live in the heap or stack, and it's address should be viewable with the reference of unary operator (&).

On the other hand (side of the expression), a rvalue is easiest to think of as a literal. They do not have a memory address that can be stored. Literals are the example of this I gave, but return values of functions also fit this category. So I guess that means they live in the stack or text? Seems odd to me.

Anyway, the real question is why are these useful. And it's because you can overload functions to handle these cases separately. probably other reasons as well. If you are writing a sorting function that doesn't want to modify the array passed to it, but you could increase efficiency if you did, you know with a rvalue you can modify the array in-place. Neat.

Now the function that sent me down this rabbit hole, std::move. Gotta go figure out what it does.

[mentalisttraceur-software]

One other design I had considered and tried to go with for C tagged unions was generating static getter and setter functions for every single member of every single union.

This had the downside that you could no longer use `DECLARE_UNION` in any place where a struct or union declaration is allowed.

From a "what code can you write?" angle that's not a huge downside. I think the biggest sucky thing about it is that it prevents defining tagged union types within a function for just that function, because functions cannot be nested in C, unless you're using a C compiler with an extension which allows that.

The bigger downside is actually the opposite: if the macros work inside a function because a common compiler has an extension which allows nested functions, then given enough usage of the header library, a bunch of people will unthinkingly write code that relies on that extension, and then it breaks for people trying to compile that code on a standard compiler, which is a downstream multiplication of badness. Better that a code author be forced to explicitly opt into unportable constructs, or not have access to them at all, than any of their users suffering unusable code due to that developer's negligence or inconsiderateness. Although it is possible for that to be outweighed if the potentially accidentally or implicitly unportable construct is valuable enough in the hands of people using it with awareness for what they are doing and compassion for their users.

Also, might think "but what if I want to expose the tagged union type in a header without exposing the getter and setter functions?", to which I say "then just expose it as an incomplete type in the header, as a pointer to the forward-declared type rather than the full definition, as you would with any other type - the getter and setter functions are conceptually equivalent to plain C member access and member assignment, so I don't see a good reason to not expose them if you are exposing the full type definition, especially since they are strictly safer and more correct than regular member access, and exposing the definition without exposing the setters and getters is just asking for unsafe direct member access and assignment."

Anyway, I do like this design more in a lot of ways. It eliminates all issues with lvalue vs non-lvalue distinctions, for instance. It eliminates all struggle to make sure that macros are type-safe and evaluate their arguments only once. In fact, it eliminates macros entirely from anywhere other than the single definition site, which is a huge benefit for reasoning about what the code is doing at every usage site. Eliminating macros from usage sites even makes it easier to just use the macro library to generate the plain C definitions in a separately pre-processed file and then use or release that as the actual C source from then on, although if you are doing that, it is probably worthwhile to just use a tool better suited for code generation than the C pre-processor. Dedicated getter and setter functions can be used as function pointers and so on as well, which opens up more uses with less boilerplate that the user has to write.

I'm probably going to implement that version too, and then play with using both and think about it until I have a better idea of which one is generally better. If I really can't decide then I might make both versions available under different header names, with slightly different prefix names.

[arunabadami-blog]

Top 25 C++ Interview Questions for Experienced

Q #1) What is the basic structure of a C++ program?

In cases like this, we're using a directive that informs the compiler to add a header while"iostream.h" that is utilized for fundamental input/output later from the program.

The following line is your"primary" function that returns an integer. The major function is the beginning point of implementation for any C++ program. Irrespective of its status in the source code file, the principal function's contents are always implemented first from the C++ compiler.

We could observe open curly braces that point to the beginning of a block of code within another line. Next, we view the programming education or the amount of code that utilizes the count that's the standard output stream (its definition is current in iostream.h).

This output takes a series of characters and prints into a regular output device. . Please be aware that every C++ schooling ends with a semicolon (;-RRB-, which will be very much needed, and omitting it's going to lead to compilation errors.

Before shutting the braces}we visit the following line" return." This is the come the point to the major function.

Each C++ application will have a fundamental arrangement, as shown above, having a preprocessor directive, chief purpose announcement followed by a block of code, and a returning point to the major purpose, which indicates successful implementation of this program.

Q #2) Which are the Opinions in C++?

Answer: Remarks in C++ are merely a bit of source code dismissed by the compiler. They are only beneficial to get a developer to add a description or additional information regarding their origin code.

Q #3) Difference within Declaration and Definition of a variable.

Response: The statement of a factor is simply defining the data type of a variable and the variable name. As a consequence of the announcement, we inform the compiler to book the area for a memory factor based on the data type defined.

Q #4) Comment on Local and Global extent of a variable.

Answer: The range of a variable is defined as the degree of the app code where the factor remains active, i.e., it could be announced, defined, or worked with.

There are two Kinds of extent in C++:

Neighborhood Scope: A factor is said to have a local range or is local when it's declared in a code block. The factor remains active only within the cube and isn't available outside the code block.

International Scope: A factor has a global range when it's available throughout the application. A global variable is declared in addition to the app before all of the function definitions.

Q #5) What's the precedence when there are a worldwide variable and a neighborhood factor from the app with the same title?

Answer: Whenever there's a local variable with the same title as a global variable, the compiler gives precedence to the local factor.

Q #6) If there are a worldwide variable and Local factor with the same title, how will you get the global variable?

Answer: whenever there are two factors with the identical title but a different extent, i.e., one is a local variable, and the other is a global variable, the compiler will give decision to a local factor.

Applying this operator, we could get the value of this global factor.

Q #7) How many methods are there to initialize an int with a Constant?

Answer: There are just two ways:

The initial format employs conventional C notation.

Q #8) What's a Constant?

Answer A constant is an expression which has a fixed value.

Aside from the decimal, C++ additionally supports two constants, i.e., octal (into the base 8) and hexadecimal (into the bottom 16) constants.

Q #9) How do you define/declare constants in C++?

Answer: In C++we could specify our constants with the #define preprocessor directive.

Q #10) Comment on Assignment Operator in C++.

Answer: Assignment operator at C++ is employed to assign a value to some other variable.

A = 5;

The line of code specifies the integer value 5 to changeable a.

The part in the operator's left is called an lvalue (left value) along with the best as rvalue (good value). Lworth should stay a factor, whereas the ideal side may be a constant, a variable, the result of an operation, or some other mixture of those.

The mission operation always occurs in the right to left rather than in reverse.

One property that C++ has within the other programming languages is the assignment operator may be utilized as the value (or a part of an rvalue) for a different mission.

Q #11) What's the distinction between equivalent to -LRB-==-RRB- and Assignment Operator (=-RRB-?

Answer: In C++, equivalent to -LRB-==-RRB- and assignment operator (=-RRB- are just two entirely different operators.

Equal into -LRB-==-RRB- is a relational equality operator which evaluates two expressions to determine whether they're equivalent and returns true if they're similar and false if they're not.

The assignment operator (=-RRB- can be employed to assign a value to some variable. Hence, we may have an intricate assignment performance within the relational equality operator for analysis.

Q #12) What are the different Arithmetic Operators in C++?

Answer: C++ supports the following arithmetic operators:

+ addition

– subtraction

* multiplication

/ division

% module

Q #13) Which are a Variety of Compound Assignment Operators in C++?

Answer: Following will be the Compound assignation operators at C++:

Q #14) State the difference between Pre and Post Increment/Decrement Operations.

Answer: C++ enables two operators, i.e ++ (increment) and --(decrement), which permit you to add 1 to the present value of a factor and subtract one from the factor, respectively.

Q #15) Which will be the Extraction and Insertion operators at C++? Explain with illustrations.

Answer: From the iostream.h library of C++, cin, and cout would be the 2 data streams which are used for output and input respectively. Cout is generally directed to the display and cin is delegated to the computer keyboard.

"cin" (extraction operator): By utilizing overloaded operator >> using cin flow, C++ manages the standard input.

As shown from the preceding case, an integer variable'age' is announced and it waits for cin (keyboard) to input the information. "cin" procedures the input when the RETURN key is pressed.

It transmits the information that followed it to the cout stream.

Explain with illustrations.

Q #16) What is the difference between while and do while loop? Explain with examples.

Answer: The arrangement of while loop in C++ is:

The announcement block below while is implemented so long as the illness in the given expression is true.

Q #17) What do you mean by ‘void’ return type?

Answer: All works must return a value according to the overall syntax.

Nonetheless, in the event, if we do not need a function to return some value, we utilize"emptiness " to imply that. It follows that we utilize"emptiness " to signify that the function has no return value or it yields"emptiness ".

Q #18) Explain Pass by Value and Pass by Reference.

Answer: whilst passing parameters into the function utilizing"Pass by Value", we pass a copy of the parameters into the function.

Therefore, whatever alterations are made to the parameters in the called function aren't handed back to the calling function. Thus the variables from the calling function stay unchanged.

Q #19) Which are Default Parameters? How are they assessed at the C++ work?

Answer: Default Parameter is a value that's assigned to each parameter whilst announcing a purpose.

This value can be used if this parameter is left clean when calling to the purpose. To define a default value for a specific parameter, we just assign a value to the parameter from the function statement.

If the value isn't passed for this parameter through the function call, then the compiler uses the default value supplied. When a value is defined, then that default value is stepped on along with the passed value is utilized.

Q #20) What's an Inline role in C++?

Answer: Inline function is a function that's compiled by the compiler since the purpose of calling the function, and the code has been substituted at that point. This makes compiling quicker. This function is characterized by prefixing the function prototype using the keyword"inline."

Such acts are valuable only when the code of this inline function is small and easy. Though a purpose is described as Inline, it's completely compiler determined to appraise it as directional or not.

Advanced-Data Construction

Arrays

Q #21) Why are arrays generally processed together for loop?

Answer: Array employs the index to traverse all its components.

If A is an array, then all its components are obtained as A[I]. Everything is necessary for this to work is an iterative block using a loop variable I, which functions as an indicator (counter) incrementing from 0 to A.length-1.

This is just what a loop does, and that is why we process arrays using for loops.

"delete" is used to discharge one chunk of memory that was allocated with new.

Q #23) What's wrong with this code?

Answer: the aforementioned code will be syntactically correct and will compile fine.

The one issue is it will only delete the first part of this array. Although the whole selection is deleted, just the destructor of this first element will be called, and the memory to the first element is published.

Q #24) What is the sequence in which the items in an array are destroyed?

Answer: Objects within an array are destructed in the opposite order of construction: First assembled, last destructed.

Q #25) What's wrong with this code?

Answer: From the preceding code, the pointer is null. Per the C++ 03 typical, it is perfectly legal to call delete on a NULL pointer. The delete operator will look after the NULL test internally.

know more

[intercal]

I think I am going to abandon C++ for writing this language. it was a nice idea, and maybe I bit off more than I could chew, but I don't think it's what I want to be using. often I will find myself getting annoyed-the-hell-out-of while I'm writing it, and this is supposed to be a fun project. it was not a big, specific thing that caused me to drop the language, but a combination of a lot of small things:

no lifetime tracking, which I can't really complain about because that's the language. but it's still very annoying having to worry about getting a reference to something, releasing that reference, and then taking it again in case its position in memory had changed.

implicit integer narrowing was probably what caused me to stop. say you have a 16 bit integer, and you accidentally try to shove it into an 8 bit argument (which I was starting to run into). it will happily chop off the top 8 bits and compile your program without telling you.

incomplete implementations of the current standard. C++23 was finalized last year, but gcc and ESPECIALLY clang (holy fuck they are so behind) have huge chunks missing.

the standard library feels really incomplete and not integrated with the rest of the language with its newest features. I was originally going to use std::u8string everywhere just to show that I plan on using utf-8 strings everywhere, but passing a u8string into anything doesn't seem to have much support in the standard library functions, probably because it's so new. so why would anyone want to use it if it has zero support within the library it's defined in?

no native utf-8 support. I can live with this, but man it would be nice not having to pull a new library in for it.

having to think about lvalues, rvalues, glvalues, and so forth. I finally get why it's important in a language like this, but I would prefer to just ... not. lol

so yeah. I think I am going to shoot for using Rust. I hope I do not rue the day. it has its own annoying shit with pointers and memory but I hope that I can just ignore that for a while, considering I was going to ignore it for a while in C++. I'm a lot more familiar with Rust too and its pitfalls. my main worry is that I have had multiple projects completely stopped in their tracks because I made an incorrect assumption and it completely ruined my design. hopefully this won't happen since I'm just porting stuff over, but we will see.

[was-a-mistake]

We've learned much from lvalue, but in my opinion it is time to move on.

[coldmund]

Rvalue references & Move semantics (c++)

Rvalue references

C++의 lvalue는 named variable처럼 주소를 얻을 수 있는 것이며 rvalue는 그렇지 않은 것이다(예를 들어 상수, 임시 객체나 값).

rvalue reference는 rvalue에 대한 참조이며, 특히 rvalue가 임시객체일 경우 적용된다.

rvalue reference의 목적은 임시 객체가 사용될 경우 특정 함수를 선택할 수 있도록 하는 것이며 이를 이용해 덩치 큰 객체의 복사를 pointer의 복사로 구현할 수 있다.

함수의 parameter에 &&를 추가하여 표시한다(ex. type &&name). 정확히는 universal reference라고 한다던가...

일반적으로 임시객체는 const type&로 표시하지만 rvalue reference를 사용하는 overload된 함수가 있을 경우 임시 객체는 해당 함수로 처리된다.

// 1. lvalue reference void incr(int &value) { cout << "increment with lvalue reference" << endl; ++value; } // 2. rvalue reference void incr(int &&value) { cout << "increment with rvalue reference" << endl; ++value; } int a = 10, b = 20; incr(a); // call 1. incr(a + b); // call 2. incr(3); // call 2. incr(std::move(b)) // call 2.

Move semantics

object에 move semantics를 사용하기 위해서는 move constructor와 move assignment operator가 필요하다. 둘 다 source object로부터 member variable을 복사하고 source object의 variable은 null value로 초기화한다(shallow copy).

move constructor와 move assignment operator는 모두 noexcpet여야 한다.

class Spreadsheet { public: Spreadsheet(Spreadsheet &&src) noexcept; Spreadsheet &operator=(Spreadsheet &&rhs) noexcept; }; Spreadsheet::Spreadsheet(Spreadsheet &&src) noexcept { mCells = src.mCells; ... src.mCells = nullptr; ... } Spreadsheet &Spreadsheet::operator=(Spreadsheet &&rhs) noexcept { if(this == &rhs) return *this; freeMemory(); // remove previous value mCells = rhs.mCells; ... rhs.mCells = nullptr; ... return *this; }

move constructor와 move assignment operator가 없을 경우 copy constructor와 assignment operator가 사용되며 그 경우 위 code의 src.mCells = nullptr 대신 메모리 할당과 복사가 발생한다.

move constructor와 move assignment operator는 명시적으로 삭제되거나 기본값처리할 수 있다(explicitly deleted or defaulted).

std::move() 함수는 실제로 아무것도 옮기지 않는다. lvalue reference를 rvalue reference로 바꿀 뿐이다(EMC++).

rvalue를 assign할 경우 std::move() 함수를 명시적으로 호출하지 않아도 move assignment operator가 호출된다.

#include <iostream> #include <utility> class Foo { public: Foo() { std::cout << "constructor" << std::endl; } Foo(Foo &f) { std::cout << "copy constructor" << std::endl; } Foo(Foo &&f) noexcept { std::cout << "move constructor" << std::endl; } Foo &operator=(const Foo &f) { std::cout << "assignment" << std::endl; } Foo &operator=(const Foo &&f) noexcept { std::cout << "move assignment" << std::endl; } }; Foo f1() { Foo f; return f; } Foo f2() { return f1(); } int main(int argc, char **argv) { Foo f; std::cout << "TEST1" << std::endl; f = f1(); // move assignment std::cout << "TEST2" << std::endl; f = std::move(f1()); // move assignment std::cout << "TEST3" << std::endl; f = f2(); // move assignment std::cout << "TEST4" << std::endl; f = std::move(f2()); // move assignment return 0; }

[mjones140-blog]

Repost - Use JsFiddle For Web Tab 1.0

Repost – Use JsFiddle For Web Tab 1.0

function MD5(string) { function RotateLeft(lValue, iShiftBits) { return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits)); } function AddUnsigned(lX, lY) { var lX4, lY4, lX8, lY8, lResult; lX8 = (lX & 0x80000000); lY8 = (lY & 0x80000000); lX4 = (lX & 0x40000000); lY4 = (lY & 0x40000000); lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF); if (lX4 & lY4) { return (lResult ^ 0x80000000 ^ lX8 ^…

[jimsjoo]

Universal reference unpack

Universal(Forwarding) reference은 LValue 레퍼런스일 때는 &로, RValue 레퍼런스일 때는 &&로 해석되는 것을 의미한다. #include <iostream> #include <map> std::map<std::string, int> get_map() { return { { "Hello", 1 }, { "World", 2 }, { "South Korea", 3 }, { "Seoul", 4 }, }; } int main() { for (auto&& [ k, v ] : get_map()) std::cout << "k=" << k << " v=" << v << '\n'; return 0; }

[nmjnaaa]

Assignment Operator

//The Assignment Operator

#include<iostream> using namespace std;

int main() {  // Initialsing variables  const int num1 {10};  int num2 {20};

 //num1 = 100; /* Reinitialsing the num1 variable */

 //num1 = num2; /* Value of num2 is assigned to num1 */

 //num1="Frank";  /* error: invalid conversion from 'const char*' to 'int' [-fpermissive] */

 //num1 = 100;  /* here const int num1 {10} is applied   * error: assignment of read-only variable 'num1'num1 = 100;   */

 //100 = num1;  /* error: lvalue required as left operand of assignment 100 = num1;  */

 cout<<num1<<endl;  cout<<num2<<endl;

 return 0; }