Здравствуйте, Долгавин Алексей Сергеевич!

int это целочисленный тип, (т.е. переменные с таким типом могут хранить только целочисленные значения), а int* это тип - указатель на целочисленное значение, т.е. в переменной с таким типом будет хранится указатель на некоторе целое число.
Например:
int a = 5; // целочисленная переменная
int* pointer; // указатель на int
pointer = &a; // (& - операция взятия адреса, нам это нужно для указателя)
*pointer = 0; // теперь a равна 0

тоже самое касается и типов char, char*, только char хранит обычно меньшие целые числа (или код символа, но сути это не меняет) чем int (обычно char это 1 байт т.е. для беззнаковых переменных это 0..255)

Здравствуйте, Долгавин Алексей Сергеевич!
Покажу на примере:
int a=10; //объявление целого числа
int* b; //объявление указателя на целое число
b=&a;// теперь в b храниться адрес переменной a, т.е. указывает на то место в памяти где расположено значение переменной a
int* c; // объявление массива целых чисел
c=new int[100];//массив из 100 элементов
int d[3]={1,2,3};
int* e=&d;//переменная e указывает на первый элемент массива d, т.е. e[0]==d[0], e[1]==d[1], e[2]==d[2]

вместо int можно подставить любой тип.

Удачи!

Здравствуйте, Долгавин Алексей Сергеевич!

int - Это целочисленные данные, находящиеся в памяти (занимающие в памяти 2-4 байт, в зависимости от используемой платформы);
*int - Это указатель на целочисленные данные, находящиеся в оперативной памяти.

Например:

unsigned int i = 0;// Объявлена переменная i, которая является целым, беззнаковым числом
unsigned int *ptri = &i;// Объявлен указатель на переменную i, целого беззнакового численного типа, где "&" - операция взятия адреса в памяти переменной i

Итого, * - обозначает УКАЗАТЕЛЬ НА ДАННЫЕ, а не сами данные.

Например, чтобы записать в переменную i значение 5, нужно сделать так:

i = 5;// Это прямое присваивание значения 5 переменной i
*ptri = 5;// Присваивание переменной i значения 5 через указатель; Эту запись нужно расшифровывать так: значению, лежащему в памяти по указателю ptri присвоить 5; т.е., в данном случае, * - является синонимом слов "значению, лежащему по указателю..."

Чтобы получить значение i, нужно:

unsigned int x = i;// Просто присваиваем вновь объявленной переменной x значение переменной i
unsigned int x = *ptri;// Переменной x присваиваем значение в памяти, лежащее по указателю ptri (а так как указатель у нас указывает на i (unsigned int *ptri = &i), то в переменную x загрузится значение переменной i)
С char и char* всё то же самое: char - это тип данных (однобайтовое целое или символ), лежащих в памяти, а char* - это указатель на символьные данные, которые лежат в памяти по адресу, на который указывает char*.

Например:

#include <stdio.h>
const char constString[] = "Test string";// Это символьный массив-константа (массив из символов = строка)
printf("\n%s", constString);// Это вывод этой строки; %s - это значит мы должны в параметрах дать _указатель_ на строку, мы его и даём, так как _массив_ в язке С/С++ и _является_указателем_!!!

Т.е., вышеприведённый фрагмент эквивалентен такому фрагменту:
#include <stdio.h>
const char constString[] = "Test string";
const char *str = &constString[0];// В указатель str мы пихаем адрес первого элемента массива constString
printf("\n%s", str);// Вывод той же самой строки
char *s;
char c = ‘t‘;
s = (char *) str;// Или...
s = &((char *) constString[0]);
s[0] = c;// Заменили первую букву в строке на строчную (вместо прописной)...:)
c = ++s;// В переменную c записали _вторую_ букву строки, т.е. сейчас в переменной c буква ‘e‘, а s указывает не на начало строки, а на её _вторую_ букву!

Здравствуйте, Долгавин Алексей Сергеевич!
Вообще тема указателей довольно обширная. Есть типизированные и не типизированные указатели:
void *p; // не типизированный
type *p; // типизированный (вместо type - любой тип, кроме void, как встроенный, так и пользовательский)
Далее про типизированные.
Чтобы присвоить указателю какой-то адрес, можно делать так:
type t;
type *pt = &t; // (унарный оператор & - взятие адреса)

Также при помощи указателей можно адресовать массивы:
type x;
type t[10];
type *pt;
pt = t; // на первый элемент
pt = &t[5]; // на шестой элемент
pt++; // на седьмой элемент
*pt = x; // присваиваем седьмому элементу значение x (для type должен присутствовать оператор присваивания)

pt -= 4; // на 4 позиции назад (pt == &t[2])

Также при помощи указателей можно обращаться к полям и методам указываемой структуры или класса через оператор -> (вместо .)

Вообще неплохо бы взять какую-то книжку по C++ и прочитать про указатели.

Здравствуйте, Долгавин Алексей Сергеевич!
Со звездочкой - это указатели на области памяти, содеражащие значения указанного типа.

Здравствуйте, Долгавин Алексей Сергеевич!

http://www.codeproject.com/cpp/pointers.asp по этому поводу.

Здравствуйте, Долгавин Алексей Сергеевич!

Маленькое дополнение касательно размеров переменных:

Указатель - тоже переменная, которая хранит вполне определённого вида число
В частности на IBM-PC с 32 разрядной архитектурой указатель - это закамуфлированный
long. Длинну указателя в байтах можно узнать так: int* x;cout<<sizeof(x);

В итоге получаем:

int - 2 байта со знаком
char - 1 байт без знака
int* - 4 байта
char* - 4 байта

Эти размеры могут менятся от платформы к платформе!
Например на 64 разрядных процессорах указатели могут стать 8-байтовыми.

Здравствуйте, Долгавин Алексей Сергеевич!

звёздочка означает указатель.
т.е.:
"int a" говорит о том, что переменная "a" целого типа;
"int* a" говорит о том, что переменная "a" содержит указатель (адрес памяти) где хранится целое число. в этом случае под "a" необходимо, прежде чем использовать, выделить память...
например:

int* a; // объявляем
a = new int; // выделяем память
*a = 7; // по адресу из "a" заносим число 7
delete a; // освобождаем память;

ещё вот такой пример:

int a; // переменная
int *b; // указатель
b = new int; // выделяем память
scanf("%i", &a); // считать в "a" челое число (нужно в "scanf" давать адрес переменной - &a означает взятие адреса переменной "а")
scanf("%i", b); // в этом случае адрес брать не нужно, т.к. "b" - указатель (адрес)
delete b; // удаляем
a = 5;
b = &a; // в "b" заносим указатель на "a"
*b = 7; // по адресу из "b" заносим 7 - теперь и "a" равно 7, т.к. "b" указывает на ячейку памяти, где хранится "a"

с "char" ситуация аналогичная, только это не целый тип, а символьный