which keyword denotes friends functions and classes?
more information: [c++ friend functions](http://www.tutorialspoint.com/cplusplus/cpp_friend_functions.htm)
Add friends The basic idea here is that your adding properties to the model that EF can use to make a relationship. Right you're trying to create a relationship of type `User` and that is creating an error. To assign a composite key each key needs to be a type compatible with a `Key` field, not a navigation property. So we add `UserId` and `FriendId` of type `int`, `string` or `GUID` etc. and create a relationship off those properties.



```
public class Relationship
{
    public User Friend { get; set; }

    public User User { get; set; }

    public int FriendId { get; set; }

    public int UserId { get; set; }

    public DateTimeOffset RelationshipInitializationDate { get; set; }
}

public class User
{
    public int UserId { get; set; }
}

```

You can now define a composite key across `UserId` and `FriendId`. Something like this should do:



```
public class NorthwindContext : DbContext
{
     public NorthwindContext(DbContextOptions<NorthwindContext> options):base(options) { }

     public NorthwindContext() { }

     protected override void OnModelCreating(ModelBuilder builder)
     {
         builder.Entity<Relationship>().HasKey(table => new {
         table.FriendId, table.UserId
         });
     }
     public DbSet<Relationship> Relationships { get; set; }
     public DbSet<User> Users { get; set; }
}

```

[Source: Medium - How To: Entity Framework Core relationships, composite keys, foreign keys, data annotations, Code First and Fluent API](https://medium.com/radzenhq/how-to-entity-framework-core-relationships-composite-keys-foreign-keys-data-annotations-code-f4b238086463) 1.i made my ( ) buying and selling stocks (1.wealthy 2.fortune 3.treasure)

2.in team sports, how all members work as a group is more important than how they perform ( ) (1.frequently 2.completely 3.individually 4.typically)

3.the professor did his best to ( )the students with new ideas.
 (1.display 2.witness 3.review 4.acquaint )

4.i made my ( ) buying and selling stocks. (1.wealthy 2.fortune 3.treasuer)

5.there isn't ( ) beef in the kitchen. (1.some 2.many 3.two 4.any )

6.last friday ( )my sister's birthday,and she had a good time.
 (1.had 2.is 3.was 4.has)

7.the students started ( ) the park, and rode their bicycles along the road,
 (1.from 2.in 3.at 4.to )

8.younger sister who will help me with my homework after you go abroad for studies?
older sister ( )
younger sister: i don't know if it will be enough.
(1.your classmates all need to do their homework too. 
2.the teacher will want you to turn your assignments in on time.
3.mom and dad can't afford to hire a tutor,
4.just do your best amd you'll be fine .)

9.my recent trip to europe has left a ( ) impression on me.
( 1.forever 2.final 3.lasting 4.long)

10.any assets that can be used to make immediate payments are comsidered.
(1.indemnity 2.liquidity 3.liability 4.stock)

11.how much ( ) did she have last night?
(1.books 2.pens 3.homework 4.cats)

12.all of us must have the ( ) that there is no free lunch.
(1.know-how 2.dispute 3.wonder 4.awareness )

13.today is those ( ) birthday.
(1.a gril 2.girl 3.girl's 4.girls' )

14.these two photographs are too small. let's have them ( )
(1.formalized 2.increased 3.expanded 4.enlarged ) Since you are storing pointer to type objects why not try using polymorhism by writing a base method called displayPay() declared with the keyword virtual that would be overloaded with in each of the inherited classes. Then you can loop through the vector of pointer to StaffMembers calling the displayPay() method and the correct version of displayPay() will be called for each referenced object. Acquaintances - people I work with, know through other friends, members of committees or groups I belong to. These are people I know but do associate with outside of the confines of the source of our meeting. We are 'friendly' but not yet friends.   

Groupies - OK this is not a recognized friendship group but these at the people to me that I spend time with but would not necessarily share my deepest thoughts and hopes with nor would I want to know theirs. This is light and fun based.   

Confidants - People I share my self with who know about me and whom I know all about. These are friends in the truest sense of the word for they are not only people I share time with but people I share everything with and whom I would consider family. **IMPORTANT NOTE:** You have to **sort your data** first.







The part I didn't get is that in the example construction



```
groups = []
uniquekeys = []
for k, g in groupby(data, keyfunc):
   groups.append(list(g))    # Store group iterator as a list
   uniquekeys.append(k)

```

`k` is the current grouping key, and `g` is an iterator that you can use to iterate over the group defined by that grouping key. In other words, the `groupby` iterator itself returns iterators.


Here's an example of that, using clearer variable names:



```
from itertools import groupby

things = [("animal", "bear"), ("animal", "duck"), ("plant", "cactus"), ("vehicle", "speed boat"), ("vehicle", "school bus")]

for key, group in groupby(things, lambda x: x[0]):
    for thing in group:
        print("A %s is a %s." % (thing[1], key))
    print("")
    

```

This will give you the output:



> 
> A bear is a animal.  
> 
> A duck is a animal.
> 
> 
> A cactus is a plant.
> 
> 
> A speed boat is a vehicle.  
> 
> A school bus is a vehicle.
> 
> 
> 


In this example, `things` is a list of tuples where the first item in each tuple is the group the second item belongs to.


The `groupby()` function takes two arguments: (1) the data to group and (2) the function to group it with.


Here, `lambda x: x[0]` tells `groupby()` to use the first item in each tuple as the grouping key.


In the above `for` statement, `groupby` returns three (key, group iterator) pairs - once for each unique key. You can use the returned iterator to iterate over each individual item in that group.


Here's a slightly different example with the same data, using a list comprehension:



```
for key, group in groupby(things, lambda x: x[0]):
    listOfThings = " and ".join([thing[1] for thing in group])
    print(key + "s:  " + listOfThings + ".")

```

This will give you the output:



> 
> animals: bear and duck.  
> 
> plants: cactus.  
> 
> vehicles: speed boat and school bus.
> 
> 
> hi there! a member variable (or field) is simply a variable that belongs to that class. you create it just like you would any other. in this case, it wants a public string.
```java
public string title;
```
this creates a field/member variable that belongs to this class. it is public, of type string and has the name title. 
hope this helps! :sparkles: want, regard, praise, include, push, buy, warm, pay attention, let go, encourage, permit, admit, allow, support, flatter, compliment, accept, sanction, approve, release, socialize, respect, be friendly, use, heat, welcome, note. Can you show the calculate function that you've wrote so far? When Java needs to load a class it gets the variable "CLASSPATH", which should contain a list of directories and/or jar files, and searches all those locations to find the .class file(s).  

Line 4 appends %AGLET\_HOME%\lib\myJarFile.jar to the CLASSPATH variable.  

AGLET\_HOME was set to C:\Users\MARIA\Desktop\aglets, so line 4 appends the jar file  

C:\Users\MARIA\Desktop\aglets\lib\myJarFile.jar  

to the CLASSPATH, so java will be able to find whatever classes are stored in that jar.