L7 - Ethereum Smart Contracts Flashcards

Question

Private

Answer 1

can only be called internally by the contract who owns the method. Derived contracts cannot access a private method of their parent contract.

Answer 2

because the EVM is a stack machine rather than a register machine, all computations are done on a data region called the stack.

Answer 3

- storage is comparable to a hard drive. Reading the storage is expensive and initializing and modifying storage is even more expensive. - memory is temporary. --> memory has a lower gas consumption. It is better to do intermediary calculations here and store the result in storage.

Answer 4

in storage by default

Answer 5

Inside a function

Answer 6

In memory by default .

Answer 7

Then we create a pointer to the numbers array's storage location. If the storage keyword was not used, Solidity would still have created myArray as a pointer to the numbers array's storage location.

Answer 8

int[] memory myArray = numbers; ``` // has no influence: myArray[0] = 0; ``` Then the array "myArray" only exists locally. So we create a copy of the array numbers and if we change something in myArray then the numbers array is not altered.

Answer 9

For declaring constructors and addresses that can receive/send Ether. (e.g., constructor payable { /* … */ }, function withdraw (address payable _to) public { /* … */ }). While implicit conversions are allowed from address payable to address, a casting function called payable (

) must be used for conversions from address to address payable. address public customer; ``` function transfer (uint amount) public { payable(customer).transfer(amount); }

```

Answer 10

The fallback function is called when no other function matches the function call. (e.g. when Ether is sent to a contract without a receive function). It can't have any parameters and doesn't return anything.

Answer 11

When you define the same function twice with a different signature. This can be helpful if a method needs to be adapted to certain situations. ``` Example function sendEther(uint amount) { require(this.balance >= amount); payable(msg.sender).transfer(amount); } function sendEther(uint amount, address payable to) { require(this.balance >= amount); to.transfer(amount); } ``` If sendEther() is called without the address argument, the Ether will be sent to the caller. Otherwise, it will be sent to the address passed as parameter to the function.

Answer 12

Usually, function parameters are passed by their defined signature order. Solidity supports the concept of named calls. The named calls principle allows to pass function parameters explicitly via a dictionary. ``` return myAddFunction({ b: 2, a:4 }); ```

Answer 13

Then the functions are overloaded. In case both functions have the same signature, the sub contract's function will overload the parent's function. However, the parent function can still be explicitly accessed using the super keyword.

Answer 14

The function resolution order is not intuitive. When you draw the contracts in a tree like diagram then you start at the bottom go up and then horizontal before you go up further.

Answer 15

A function is abstract if it does not have a body. A contract is abstract if one or more functions are abstract.

Answer 16

No. A contract that inherits from an abstract contract must implement and override all methods from the base contract to be compliable.

Answer 17

Similar to an abstract class but more restrictive. Does not allow to define constructor, variables, structs and enums. It cannot inherit from a contract or implement another interface. ``` Example interface CarInsurance { function payMonthlyFee() returns (boolean result); } ``` One contract can implement multiple interfaces at once.